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 <stdarg.h>
  18 #include <ctype.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21
  22 #include "platform.h"
  23
  24 #if !defined(PLATFORM_WIN32)
  25 #include <pwd.h>
  26 #include <sys/param.h>
  27 #endif
  28
  29 #include "misc.h"
  30 #include "setup.h"
  31 #include "random.h"
  32 #include "text.h"
  33 #include "image.h"
  34
  35
  36 /* ========================================================================= */
  37 /* some generic helper functions                                             */
  38 /* ========================================================================= */
  39
  40 /* ------------------------------------------------------------------------- */
  41 /* platform independent wrappers for printf() et al. (newline aware)         */
  42 /* ------------------------------------------------------------------------- */
  43
  44 static void vfprintf_newline(FILE *stream, char *format, va_list ap)
  45 {
  46   char *newline = STRING_NEWLINE;
  47
  48   vfprintf(stream, format, ap);
  49
  50   fprintf(stream, "%s", newline);
  51 }
  52
  53 static void fprintf_newline(FILE *stream, char *format, ...)
  54 {
  55   if (format)
  56   {
  57     va_list ap;
  58
  59     va_start(ap, format);
  60     vfprintf_newline(stream, format, ap);
  61     va_end(ap);
  62   }
  63 }
  64
  65 void fprintf_line(FILE *stream, char *line_chars, int line_length)
  66 {
  67   int i;
  68
  69   for (i = 0; i < line_length; i++)
  70     fprintf(stream, "%s", line_chars);
  71
  72   fprintf_newline(stream, "");
  73 }
  74
  75 void printf_line(char *line_chars, int line_length)
  76 {
  77   fprintf_line(stdout, line_chars, line_length);
  78 }
  79
  80 void printf_line_with_prefix(char *prefix, char *line_chars, int line_length)
  81 {
  82   fprintf(stdout, "%s", prefix);
  83   fprintf_line(stdout, line_chars, line_length);
  84 }
  85
  86
  87 /* ------------------------------------------------------------------------- */
  88 /* string functions                                                          */
  89 /* ------------------------------------------------------------------------- */
  90
  91 /* int2str() returns a number converted to a string;
  92    the used memory is static, but will be overwritten by later calls,
  93    so if you want to save the result, copy it to a private string buffer;
  94    there can be 10 local calls of int2str() without buffering the result --
  95    the 11th call will then destroy the result from the first call and so on.
  96 */
  97
  98 char *int2str(int number, int size)
  99 {
 100   static char shift_array[10][40];
 101   static int shift_counter = 0;
 102   char *s = shift_array[shift_counter];
 103
 104   shift_counter = (shift_counter + 1) % 10;
 105
 106   if (size > 20)
 107     size = 20;
 108
 109   if (size > 0)
 110   {
 111     sprintf(s, "                    %09d", number);
 112     return &s[strlen(s) - size];
 113   }
 114   else
 115   {
 116     sprintf(s, "%d", number);
 117     return s;
 118   }
 119 }
 120
 121
 122 /* something similar to "int2str()" above, but allocates its own memory
 123    and has a different interface; we cannot use "itoa()", because this
 124    seems to be already defined when cross-compiling to the win32 target */
 125
 126 char *i_to_a(unsigned int i)
 127 {
 128   static char *a = NULL;
 129
 130   checked_free(a);
 131
 132   if (i > 2147483647)   /* yes, this is a kludge */
 133     i = 2147483647;
 134
 135   a = checked_malloc(10 + 1);
 136
 137   sprintf(a, "%d", i);
 138
 139   return a;
 140 }
 141
 142
 143 /* calculate base-2 logarithm of argument (rounded down to integer;
 144    this function returns the number of the highest bit set in argument) */
 145
 146 int log_2(unsigned int x)
 147 {
 148   int e = 0;
 149
 150   while ((1 << e) < x)
 151   {
 152     x -= (1 << e);      /* for rounding down (rounding up: remove this line) */
 153     e++;
 154   }
 155
 156   return e;
 157 }
 158
 159 boolean getTokenValueFromString(char *string, char **token, char **value)
 160 {
 161   return getTokenValueFromSetupLine(string, token, value);
 162 }
 163
 164
 165 /* ------------------------------------------------------------------------- */
 166 /* counter functions                                                         */
 167 /* ------------------------------------------------------------------------- */
 168
 169 #if defined(PLATFORM_MSDOS)
 170 volatile unsigned long counter = 0;
 171
 172 void increment_counter()
 173 {
 174   counter++;
 175 }
 176
 177 END_OF_FUNCTION(increment_counter);
 178 #endif
 179
 180
 181 /* maximal allowed length of a command line option */
 182 #define MAX_OPTION_LEN          256
 183
 184 #ifdef TARGET_SDL
 185 static unsigned long mainCounter(int mode)
 186 {
 187   static unsigned long base_ms = 0;
 188   unsigned long current_ms;
 189   unsigned long counter_ms;
 190
 191   current_ms = SDL_GetTicks();
 192
 193   /* reset base time in case of counter initializing or wrap-around */
 194   if (mode == INIT_COUNTER || current_ms < base_ms)
 195     base_ms = current_ms;
 196
 197   counter_ms = current_ms - base_ms;
 198
 199   return counter_ms;            /* return milliseconds since last init */
 200 }
 201
 202 #else /* !TARGET_SDL */
 203
 204 #if defined(PLATFORM_UNIX)
 205 static unsigned long mainCounter(int mode)
 206 {
 207   static struct timeval base_time = { 0, 0 };
 208   struct timeval current_time;
 209   unsigned long counter_ms;
 210
 211   gettimeofday(&current_time, NULL);
 212
 213   /* reset base time in case of counter initializing or wrap-around */
 214   if (mode == INIT_COUNTER || current_time.tv_sec < base_time.tv_sec)
 215     base_time = current_time;
 216
 217   counter_ms = (current_time.tv_sec  - base_time.tv_sec)  * 1000
 218              + (current_time.tv_usec - base_time.tv_usec) / 1000;
 219
 220   return counter_ms;            /* return milliseconds since last init */
 221 }
 222 #endif /* PLATFORM_UNIX */
 223 #endif /* !TARGET_SDL */
 224
 225 void InitCounter()              /* set counter back to zero */
 226 {
 227 #if !defined(PLATFORM_MSDOS)
 228   mainCounter(INIT_COUNTER);
 229 #else
 230   LOCK_VARIABLE(counter);
 231   LOCK_FUNCTION(increment_counter);
 232   install_int_ex(increment_counter, BPS_TO_TIMER(100));
 233 #endif
 234 }
 235
 236 unsigned long Counter() /* get milliseconds since last call of InitCounter() */
 237 {
 238 #if !defined(PLATFORM_MSDOS)
 239   return mainCounter(READ_COUNTER);
 240 #else
 241   return (counter * 10);
 242 #endif
 243 }
 244
 245 static void sleep_milliseconds(unsigned long milliseconds_delay)
 246 {
 247   boolean do_busy_waiting = (milliseconds_delay < 5 ? TRUE : FALSE);
 248
 249   if (do_busy_waiting)
 250   {
 251     /* we want to wait only a few ms -- if we assume that we have a
 252        kernel timer resolution of 10 ms, we would wait far to long;
 253        therefore it's better to do a short interval of busy waiting
 254        to get our sleeping time more accurate */
 255
 256     unsigned long base_counter = Counter(), actual_counter = Counter();
 257
 258     while (actual_counter < base_counter + milliseconds_delay &&
 259            actual_counter >= base_counter)
 260       actual_counter = Counter();
 261   }
 262   else
 263   {
 264 #if defined(TARGET_SDL)
 265     SDL_Delay(milliseconds_delay);
 266 #elif defined(TARGET_ALLEGRO)
 267     rest(milliseconds_delay);
 268 #else
 269     struct timeval delay;
 270
 271     delay.tv_sec  = milliseconds_delay / 1000;
 272     delay.tv_usec = 1000 * (milliseconds_delay % 1000);
 273
 274     if (select(0, NULL, NULL, NULL, &delay) != 0)
 275       Error(ERR_WARN, "sleep_milliseconds(): select() failed");
 276 #endif
 277   }
 278 }
 279
 280 void Delay(unsigned long delay) /* Sleep specified number of milliseconds */
 281 {
 282   sleep_milliseconds(delay);
 283 }
 284
 285 boolean FrameReached(unsigned long *frame_counter_var,
 286                      unsigned long frame_delay)
 287 {
 288   unsigned long actual_frame_counter = FrameCounter;
 289
 290   if (actual_frame_counter >= *frame_counter_var &&
 291       actual_frame_counter < *frame_counter_var + frame_delay)
 292     return FALSE;
 293
 294   *frame_counter_var = actual_frame_counter;
 295
 296   return TRUE;
 297 }
 298
 299 boolean DelayReached(unsigned long *counter_var,
 300                      unsigned long delay)
 301 {
 302   unsigned long actual_counter = Counter();
 303
 304   if (actual_counter >= *counter_var &&
 305       actual_counter < *counter_var + delay)
 306     return FALSE;
 307
 308   *counter_var = actual_counter;
 309
 310   return TRUE;
 311 }
 312
 313 void WaitUntilDelayReached(unsigned long *counter_var, unsigned long delay)
 314 {
 315   unsigned long actual_counter;
 316
 317   while (1)
 318   {
 319     actual_counter = Counter();
 320
 321     if (actual_counter >= *counter_var &&
 322         actual_counter < *counter_var + delay)
 323       sleep_milliseconds((*counter_var + delay - actual_counter) / 2);
 324     else
 325       break;
 326   }
 327
 328   *counter_var = actual_counter;
 329 }
 330
 331
 332 /* ------------------------------------------------------------------------- */
 333 /* random generator functions                                                */
 334 /* ------------------------------------------------------------------------- */
 335
 336 unsigned int init_random_number(int nr, long seed)
 337 {
 338   if (seed == NEW_RANDOMIZE)
 339   {
 340 #if defined(TARGET_SDL)
 341     seed = (long)SDL_GetTicks();
 342 #else
 343     struct timeval current_time;
 344
 345     gettimeofday(&current_time, NULL);
 346     seed = (long)current_time.tv_usec;
 347 #endif
 348   }
 349
 350   srandom_linux_libc(nr, (unsigned int) seed);
 351
 352   return (unsigned int) seed;
 353 }
 354
 355 unsigned int get_random_number(int nr, int max)
 356 {
 357   return (max > 0 ? random_linux_libc(nr) % max : 0);
 358 }
 359
 360
 361 /* ------------------------------------------------------------------------- */
 362 /* system info functions                                                     */
 363 /* ------------------------------------------------------------------------- */
 364
 365 #if !defined(PLATFORM_MSDOS)
 366 static char *get_corrected_real_name(char *real_name)
 367 {
 368   char *real_name_new = checked_malloc(MAX_USERNAME_LEN + 1);
 369   char *from_ptr = real_name;
 370   char *to_ptr   = real_name_new;
 371
 372   /* copy the name string, but not more than MAX_USERNAME_LEN characters */
 373   while (*from_ptr && (long)(to_ptr - real_name_new) < MAX_USERNAME_LEN - 1)
 374   {
 375     /* the name field read from "passwd" file may also contain additional
 376        user information, separated by commas, which will be removed here */
 377     if (*from_ptr == ',')
 378       break;
 379
 380     /* the user's real name may contain 'ß' characters (german sharp s),
 381        which have no equivalent in upper case letters (used by our fonts) */
 382     if (*from_ptr == 'ß')
 383     {
 384       from_ptr++;
 385       *to_ptr++ = 's';
 386       *to_ptr++ = 's';
 387     }
 388     else
 389       *to_ptr++ = *from_ptr++;
 390   }
 391
 392   *to_ptr = '\0';
 393
 394   return real_name_new;
 395 }
 396 #endif
 397
 398 char *getLoginName()
 399 {
 400   static char *login_name = NULL;
 401
 402 #if defined(PLATFORM_WIN32)
 403   if (login_name == NULL)
 404   {
 405     unsigned long buffer_size = MAX_USERNAME_LEN + 1;
 406     login_name = checked_malloc(buffer_size);
 407
 408     if (GetUserName(login_name, &buffer_size) == 0)
 409       strcpy(login_name, ANONYMOUS_NAME);
 410   }
 411 #else
 412   if (login_name == NULL)
 413   {
 414     struct passwd *pwd;
 415
 416     if ((pwd = getpwuid(getuid())) == NULL)
 417       login_name = ANONYMOUS_NAME;
 418     else
 419       login_name = getStringCopy(pwd->pw_name);
 420   }
 421 #endif
 422
 423   return login_name;
 424 }
 425
 426 char *getRealName()
 427 {
 428   static char *real_name = NULL;
 429
 430 #if defined(PLATFORM_WIN32)
 431   if (real_name == NULL)
 432   {
 433     static char buffer[MAX_USERNAME_LEN + 1];
 434     unsigned long buffer_size = MAX_USERNAME_LEN + 1;
 435
 436     if (GetUserName(buffer, &buffer_size) != 0)
 437       real_name = get_corrected_real_name(buffer);
 438     else
 439       real_name = ANONYMOUS_NAME;
 440   }
 441 #elif defined(PLATFORM_UNIX)
 442   if (real_name == NULL)
 443   {
 444     struct passwd *pwd;
 445
 446     if ((pwd = getpwuid(getuid())) != NULL && strlen(pwd->pw_gecos) != 0)
 447       real_name = get_corrected_real_name(pwd->pw_gecos);
 448     else
 449       real_name = ANONYMOUS_NAME;
 450   }
 451 #else
 452   real_name = ANONYMOUS_NAME;
 453 #endif
 454
 455   return real_name;
 456 }
 457
 458
 459 /* ------------------------------------------------------------------------- */
 460 /* path manipulation functions                                               */
 461 /* ------------------------------------------------------------------------- */
 462
 463 static char *getLastPathSeparatorPtr(char *filename)
 464 {
 465   char *last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_UNIX);
 466
 467   if (last_separator == NULL)   /* also try DOS/Windows variant */
 468     last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_DOS);
 469
 470   return last_separator;
 471 }
 472
 473 char *getBaseNamePtr(char *filename)
 474 {
 475   char *last_separator = getLastPathSeparatorPtr(filename);
 476
 477   if (last_separator != NULL)
 478     return last_separator + 1;  /* separator found: strip base path */
 479   else
 480     return filename;            /* no separator found: filename has no path */
 481 }
 482
 483 char *getBaseName(char *filename)
 484 {
 485   return getStringCopy(getBaseNamePtr(filename));
 486 }
 487
 488 char *getBasePath(char *filename)
 489 {
 490   char *basepath = getStringCopy(filename);
 491   char *last_separator = getLastPathSeparatorPtr(basepath);
 492
 493   if (last_separator != NULL)
 494     *last_separator = '\0';     /* separator found: strip basename */
 495   else
 496     basepath = ".";             /* no separator found: use current path */
 497
 498   return basepath;
 499 }
 500
 501
 502 /* ------------------------------------------------------------------------- */
 503 /* various string functions                                                  */
 504 /* ------------------------------------------------------------------------- */
 505
 506 char *getStringCat2WithSeparator(char *s1, char *s2, char *sep)
 507 {
 508   char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
 509                                          strlen(s2) + 1);
 510
 511   sprintf(complete_string, "%s%s%s", s1, sep, s2);
 512
 513   return complete_string;
 514 }
 515
 516 char *getStringCat3WithSeparator(char *s1, char *s2, char *s3, char *sep)
 517 {
 518   char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
 519                                          strlen(s2) + strlen(sep) +
 520                                          strlen(s3) + 1);
 521
 522   sprintf(complete_string, "%s%s%s%s%s", s1, sep, s2, sep, s3);
 523
 524   return complete_string;
 525 }
 526
 527 char *getStringCat2(char *s1, char *s2)
 528 {
 529   return getStringCat2WithSeparator(s1, s2, "");
 530 }
 531
 532 char *getStringCat3(char *s1, char *s2, char *s3)
 533 {
 534   return getStringCat3WithSeparator(s1, s2, s3, "");
 535 }
 536
 537 char *getPath2(char *path1, char *path2)
 538 {
 539   return getStringCat2WithSeparator(path1, path2, STRING_PATH_SEPARATOR);
 540 }
 541
 542 char *getPath3(char *path1, char *path2, char *path3)
 543 {
 544   return getStringCat3WithSeparator(path1, path2, path3, STRING_PATH_SEPARATOR);
 545 }
 546
 547 char *getStringCopy(char *s)
 548 {
 549   char *s_copy;
 550
 551   if (s == NULL)
 552     return NULL;
 553
 554   s_copy = checked_malloc(strlen(s) + 1);
 555   strcpy(s_copy, s);
 556
 557   return s_copy;
 558 }
 559
 560 char *getStringCopyN(char *s, int n)
 561 {
 562   char *s_copy;
 563   int s_len = MAX(0, n);
 564
 565   if (s == NULL)
 566     return NULL;
 567
 568   s_copy = checked_malloc(s_len + 1);
 569   strncpy(s_copy, s, s_len);
 570   s_copy[s_len] = '\0';
 571
 572   return s_copy;
 573 }
 574
 575 char *getStringToLower(char *s)
 576 {
 577   char *s_copy = checked_malloc(strlen(s) + 1);
 578   char *s_ptr = s_copy;
 579
 580   while (*s)
 581     *s_ptr++ = tolower(*s++);
 582   *s_ptr = '\0';
 583
 584   return s_copy;
 585 }
 586
 587 void setString(char **old_value, char *new_value)
 588 {
 589   checked_free(*old_value);
 590
 591   *old_value = getStringCopy(new_value);
 592 }
 593
 594 boolean strEqual(char *s1, char *s2)
 595 {
 596   return (s1 == NULL && s2 == NULL ? TRUE  :
 597           s1 == NULL && s2 != NULL ? FALSE :
 598           s1 != NULL && s2 == NULL ? FALSE :
 599           strcmp(s1, s2) == 0);
 600 }
 601
 602 boolean strEqualN(char *s1, char *s2, int n)
 603 {
 604   return (s1 == NULL && s2 == NULL ? TRUE  :
 605           s1 == NULL && s2 != NULL ? FALSE :
 606           s1 != NULL && s2 == NULL ? FALSE :
 607           strncmp(s1, s2, n) == 0);
 608 }
 609
 610
 611 /* ------------------------------------------------------------------------- */
 612 /* command line option handling functions                                    */
 613 /* ------------------------------------------------------------------------- */
 614
 615 void GetOptions(char *argv[], void (*print_usage_function)(void))
 616 {
 617   char *ro_base_path = RO_BASE_PATH;
 618   char *rw_base_path = RW_BASE_PATH;
 619   char **options_left = &argv[1];
 620
 621 #if !defined(PLATFORM_MACOSX)
 622   /* if the program is configured to start from current directory (default),
 623      determine program package directory (KDE/Konqueror does not do this by
 624      itself and fails otherwise); on Mac OS X, the program binary is stored
 625      in an application package directory -- do not try to use this directory
 626      as the program data directory (Mac OS X handles this correctly anyway) */
 627
 628   if (strEqual(ro_base_path, "."))
 629     ro_base_path = program.command_basepath;
 630   if (strEqual(rw_base_path, "."))
 631     rw_base_path = program.command_basepath;
 632 #endif
 633
 634   /* initialize global program options */
 635   options.display_name = NULL;
 636   options.server_host = NULL;
 637   options.server_port = 0;
 638   options.ro_base_directory = ro_base_path;
 639   options.rw_base_directory = rw_base_path;
 640   options.level_directory    = getPath2(ro_base_path, LEVELS_DIRECTORY);
 641   options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
 642   options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
 643   options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
 644   options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
 645   options.execute_command = NULL;
 646   options.serveronly = FALSE;
 647   options.network = FALSE;
 648   options.verbose = FALSE;
 649   options.debug = FALSE;
 650
 651 #if !defined(PLATFORM_UNIX)
 652   if (*options_left == NULL)    /* no options given -- enable verbose mode */
 653     options.verbose = TRUE;
 654 #endif
 655
 656   while (*options_left)
 657   {
 658     char option_str[MAX_OPTION_LEN];
 659     char *option = options_left[0];
 660     char *next_option = options_left[1];
 661     char *option_arg = NULL;
 662     int option_len = strlen(option);
 663
 664     if (option_len >= MAX_OPTION_LEN)
 665       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
 666
 667     strcpy(option_str, option);                 /* copy argument into buffer */
 668     option = option_str;
 669
 670     if (strEqual(option, "--"))                 /* stop scanning arguments */
 671       break;
 672
 673     if (strncmp(option, "--", 2) == 0)          /* treat '--' like '-' */
 674       option++;
 675
 676     option_arg = strchr(option, '=');
 677     if (option_arg == NULL)                     /* no '=' in option */
 678       option_arg = next_option;
 679     else
 680     {
 681       *option_arg++ = '\0';                     /* cut argument from option */
 682       if (*option_arg == '\0')                  /* no argument after '=' */
 683         Error(ERR_EXIT_HELP, "option '%s' has invalid argument", option_str);
 684     }
 685
 686     option_len = strlen(option);
 687
 688     if (strEqual(option, "-"))
 689       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
 690     else if (strncmp(option, "-help", option_len) == 0)
 691     {
 692       print_usage_function();
 693
 694       exit(0);
 695     }
 696     else if (strncmp(option, "-display", option_len) == 0)
 697     {
 698       if (option_arg == NULL)
 699         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 700
 701       options.display_name = option_arg;
 702       if (option_arg == next_option)
 703         options_left++;
 704     }
 705     else if (strncmp(option, "-basepath", option_len) == 0)
 706     {
 707       if (option_arg == NULL)
 708         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 709
 710       /* this should be extended to separate options for ro and rw data */
 711       options.ro_base_directory = ro_base_path = option_arg;
 712       options.rw_base_directory = rw_base_path = option_arg;
 713       if (option_arg == next_option)
 714         options_left++;
 715
 716       /* adjust paths for sub-directories in base directory accordingly */
 717       options.level_directory    = getPath2(ro_base_path, LEVELS_DIRECTORY);
 718       options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
 719       options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
 720       options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
 721       options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
 722     }
 723     else if (strncmp(option, "-levels", option_len) == 0)
 724     {
 725       if (option_arg == NULL)
 726         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 727
 728       options.level_directory = option_arg;
 729       if (option_arg == next_option)
 730         options_left++;
 731     }
 732     else if (strncmp(option, "-graphics", option_len) == 0)
 733     {
 734       if (option_arg == NULL)
 735         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 736
 737       options.graphics_directory = option_arg;
 738       if (option_arg == next_option)
 739         options_left++;
 740     }
 741     else if (strncmp(option, "-sounds", option_len) == 0)
 742     {
 743       if (option_arg == NULL)
 744         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 745
 746       options.sounds_directory = option_arg;
 747       if (option_arg == next_option)
 748         options_left++;
 749     }
 750     else if (strncmp(option, "-music", option_len) == 0)
 751     {
 752       if (option_arg == NULL)
 753         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 754
 755       options.music_directory = option_arg;
 756       if (option_arg == next_option)
 757         options_left++;
 758     }
 759     else if (strncmp(option, "-network", option_len) == 0)
 760     {
 761       options.network = TRUE;
 762     }
 763     else if (strncmp(option, "-serveronly", option_len) == 0)
 764     {
 765       options.serveronly = TRUE;
 766     }
 767     else if (strncmp(option, "-verbose", option_len) == 0)
 768     {
 769       options.verbose = TRUE;
 770     }
 771     else if (strncmp(option, "-debug", option_len) == 0)
 772     {
 773       options.debug = TRUE;
 774     }
 775     else if (strncmp(option, "-execute", option_len) == 0)
 776     {
 777       if (option_arg == NULL)
 778         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 779
 780       options.execute_command = option_arg;
 781       if (option_arg == next_option)
 782         options_left++;
 783
 784       /* when doing batch processing, always enable verbose mode (warnings) */
 785       options.verbose = TRUE;
 786     }
 787     else if (*option == '-')
 788     {
 789       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option_str);
 790     }
 791     else if (options.server_host == NULL)
 792     {
 793       options.server_host = *options_left;
 794     }
 795     else if (options.server_port == 0)
 796     {
 797       options.server_port = atoi(*options_left);
 798       if (options.server_port < 1024)
 799         Error(ERR_EXIT_HELP, "bad port number '%d'", options.server_port);
 800     }
 801     else
 802       Error(ERR_EXIT_HELP, "too many arguments");
 803
 804     options_left++;
 805   }
 806 }
 807
 808
 809 /* ------------------------------------------------------------------------- */
 810 /* error handling functions                                                  */
 811 /* ------------------------------------------------------------------------- */
 812
 813 /* used by SetError() and GetError() to store internal error messages */
 814 static char internal_error[1024];       /* this is bad */
 815
 816 void SetError(char *format, ...)
 817 {
 818   va_list ap;
 819
 820   va_start(ap, format);
 821   vsprintf(internal_error, format, ap);
 822   va_end(ap);
 823 }
 824
 825 char *GetError()
 826 {
 827   return internal_error;
 828 }
 829
 830 void Error(int mode, char *format, ...)
 831 {
 832   static boolean last_line_was_separator = FALSE;
 833   char *process_name = "";
 834
 835   /* display warnings only when running in verbose mode */
 836   if (mode & ERR_WARN && !options.verbose)
 837     return;
 838
 839   if (mode == ERR_INFO_LINE)
 840   {
 841     if (!last_line_was_separator)
 842       fprintf_line(program.error_file, format, 79);
 843
 844     last_line_was_separator = TRUE;
 845
 846     return;
 847   }
 848
 849   last_line_was_separator = FALSE;
 850
 851   if (mode & ERR_SOUND_SERVER)
 852     process_name = " sound server";
 853   else if (mode & ERR_NETWORK_SERVER)
 854     process_name = " network server";
 855   else if (mode & ERR_NETWORK_CLIENT)
 856     process_name = " network client **";
 857
 858   if (format)
 859   {
 860     va_list ap;
 861
 862     fprintf(program.error_file, "%s%s: ", program.command_basename,
 863             process_name);
 864
 865     if (mode & ERR_WARN)
 866       fprintf(program.error_file, "warning: ");
 867
 868     va_start(ap, format);
 869     vfprintf_newline(program.error_file, format, ap);
 870     va_end(ap);
 871   }
 872
 873   if (mode & ERR_HELP)
 874     fprintf_newline(program.error_file,
 875                     "%s: Try option '--help' for more information.",
 876                     program.command_basename);
 877
 878   if (mode & ERR_EXIT)
 879     fprintf_newline(program.error_file, "%s%s: aborting",
 880                     program.command_basename, process_name);
 881
 882   if (mode & ERR_EXIT)
 883   {
 884     if (mode & ERR_FROM_SERVER)
 885       exit(1);                          /* child process: normal exit */
 886     else
 887       program.exit_function(1);         /* main process: clean up stuff */
 888   }
 889 }
 890
 891
 892 /* ------------------------------------------------------------------------- */
 893 /* checked memory allocation and freeing functions                           */
 894 /* ------------------------------------------------------------------------- */
 895
 896 void *checked_malloc(unsigned long size)
 897 {
 898   void *ptr;
 899
 900   ptr = malloc(size);
 901
 902   if (ptr == NULL)
 903     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
 904
 905   return ptr;
 906 }
 907
 908 void *checked_calloc(unsigned long size)
 909 {
 910   void *ptr;
 911
 912   ptr = calloc(1, size);
 913
 914   if (ptr == NULL)
 915     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
 916
 917   return ptr;
 918 }
 919
 920 void *checked_realloc(void *ptr, unsigned long size)
 921 {
 922   ptr = realloc(ptr, size);
 923
 924   if (ptr == NULL)
 925     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
 926
 927   return ptr;
 928 }
 929
 930 void checked_free(void *ptr)
 931 {
 932   if (ptr != NULL)      /* this check should be done by free() anyway */
 933     free(ptr);
 934 }
 935
 936
 937 /* ------------------------------------------------------------------------- */
 938 /* various helper functions                                                  */
 939 /* ------------------------------------------------------------------------- */
 940
 941 inline void swap_numbers(int *i1, int *i2)
 942 {
 943   int help = *i1;
 944
 945   *i1 = *i2;
 946   *i2 = help;
 947 }
 948
 949 inline void swap_number_pairs(int *x1, int *y1, int *x2, int *y2)
 950 {
 951   int help_x = *x1;
 952   int help_y = *y1;
 953
 954   *x1 = *x2;
 955   *x2 = help_x;
 956
 957   *y1 = *y2;
 958   *y2 = help_y;
 959 }
 960
 961 /* the "put" variants of the following file access functions check for the file
 962    pointer being != NULL and return the number of bytes they have or would have
 963    written; this allows for chunk writing functions to first determine the size
 964    of the (not yet written) chunk, write the correct chunk size and finally
 965    write the chunk itself */
 966
 967 int getFile8BitInteger(FILE *file)
 968 {
 969   return fgetc(file);
 970 }
 971
 972 int putFile8BitInteger(FILE *file, int value)
 973 {
 974   if (file != NULL)
 975     fputc(value, file);
 976
 977   return 1;
 978 }
 979
 980 int getFile16BitInteger(FILE *file, int byte_order)
 981 {
 982   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
 983     return ((fgetc(file) << 8) |
 984             (fgetc(file) << 0));
 985   else           /* BYTE_ORDER_LITTLE_ENDIAN */
 986     return ((fgetc(file) << 0) |
 987             (fgetc(file) << 8));
 988 }
 989
 990 int putFile16BitInteger(FILE *file, int value, int byte_order)
 991 {
 992   if (file != NULL)
 993   {
 994     if (byte_order == BYTE_ORDER_BIG_ENDIAN)
 995     {
 996       fputc((value >> 8) & 0xff, file);
 997       fputc((value >> 0) & 0xff, file);
 998     }
 999     else           /* BYTE_ORDER_LITTLE_ENDIAN */
1000     {
1001       fputc((value >> 0) & 0xff, file);
1002       fputc((value >> 8) & 0xff, file);
1003     }
1004   }
1005
1006   return 2;
1007 }
1008
1009 int getFile32BitInteger(FILE *file, int byte_order)
1010 {
1011   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1012     return ((fgetc(file) << 24) |
1013             (fgetc(file) << 16) |
1014             (fgetc(file) <<  8) |
1015             (fgetc(file) <<  0));
1016   else           /* BYTE_ORDER_LITTLE_ENDIAN */
1017     return ((fgetc(file) <<  0) |
1018             (fgetc(file) <<  8) |
1019             (fgetc(file) << 16) |
1020             (fgetc(file) << 24));
1021 }
1022
1023 int putFile32BitInteger(FILE *file, int value, int byte_order)
1024 {
1025   if (file != NULL)
1026   {
1027     if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1028     {
1029       fputc((value >> 24) & 0xff, file);
1030       fputc((value >> 16) & 0xff, file);
1031       fputc((value >>  8) & 0xff, file);
1032       fputc((value >>  0) & 0xff, file);
1033     }
1034     else           /* BYTE_ORDER_LITTLE_ENDIAN */
1035     {
1036       fputc((value >>  0) & 0xff, file);
1037       fputc((value >>  8) & 0xff, file);
1038       fputc((value >> 16) & 0xff, file);
1039       fputc((value >> 24) & 0xff, file);
1040     }
1041   }
1042
1043   return 4;
1044 }
1045
1046 boolean getFileChunk(FILE *file, char *chunk_name, int *chunk_size,
1047                      int byte_order)
1048 {
1049   const int chunk_name_length = 4;
1050
1051   /* read chunk name */
1052   fgets(chunk_name, chunk_name_length + 1, file);
1053
1054   if (chunk_size != NULL)
1055   {
1056     /* read chunk size */
1057     *chunk_size = getFile32BitInteger(file, byte_order);
1058   }
1059
1060   return (feof(file) || ferror(file) ? FALSE : TRUE);
1061 }
1062
1063 int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
1064                  int byte_order)
1065 {
1066   int num_bytes = 0;
1067
1068   /* write chunk name */
1069   if (file != NULL)
1070     fputs(chunk_name, file);
1071
1072   num_bytes += strlen(chunk_name);
1073
1074   if (chunk_size >= 0)
1075   {
1076     /* write chunk size */
1077     if (file != NULL)
1078       putFile32BitInteger(file, chunk_size, byte_order);
1079
1080     num_bytes += 4;
1081   }
1082
1083   return num_bytes;
1084 }
1085
1086 int getFileVersion(FILE *file)
1087 {
1088   int version_major = fgetc(file);
1089   int version_minor = fgetc(file);
1090   int version_patch = fgetc(file);
1091   int version_build = fgetc(file);
1092
1093   return VERSION_IDENT(version_major, version_minor, version_patch,
1094                        version_build);
1095 }
1096
1097 int putFileVersion(FILE *file, int version)
1098 {
1099   if (file != NULL)
1100   {
1101     int version_major = VERSION_MAJOR(version);
1102     int version_minor = VERSION_MINOR(version);
1103     int version_patch = VERSION_PATCH(version);
1104     int version_build = VERSION_BUILD(version);
1105
1106     fputc(version_major, file);
1107     fputc(version_minor, file);
1108     fputc(version_patch, file);
1109     fputc(version_build, file);
1110   }
1111
1112   return 4;
1113 }
1114
1115 void ReadBytesFromFile(FILE *file, byte *buffer, unsigned long bytes)
1116 {
1117   int i;
1118
1119   for(i = 0; i < bytes && !feof(file); i++)
1120     buffer[i] = fgetc(file);
1121 }
1122
1123 void WriteBytesToFile(FILE *file, byte *buffer, unsigned long bytes)
1124 {
1125   int i;
1126
1127   for(i = 0; i < bytes; i++)
1128     fputc(buffer[i], file);
1129 }
1130
1131 void ReadUnusedBytesFromFile(FILE *file, unsigned long bytes)
1132 {
1133   while (bytes-- && !feof(file))
1134     fgetc(file);
1135 }
1136
1137 void WriteUnusedBytesToFile(FILE *file, unsigned long bytes)
1138 {
1139   while (bytes--)
1140     fputc(0, file);
1141 }
1142
1143
1144 /* ------------------------------------------------------------------------- */
1145 /* functions to translate key identifiers between different format           */
1146 /* ------------------------------------------------------------------------- */
1147
1148 #define TRANSLATE_KEYSYM_TO_KEYNAME     0
1149 #define TRANSLATE_KEYSYM_TO_X11KEYNAME  1
1150 #define TRANSLATE_KEYNAME_TO_KEYSYM     2
1151 #define TRANSLATE_X11KEYNAME_TO_KEYSYM  3
1152
1153 void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
1154 {
1155   static struct
1156   {
1157     Key key;
1158     char *x11name;
1159     char *name;
1160   } translate_key[] =
1161   {
1162     /* normal cursor keys */
1163     { KSYM_Left,        "XK_Left",              "cursor left" },
1164     { KSYM_Right,       "XK_Right",             "cursor right" },
1165     { KSYM_Up,          "XK_Up",                "cursor up" },
1166     { KSYM_Down,        "XK_Down",              "cursor down" },
1167
1168     /* keypad cursor keys */
1169 #ifdef KSYM_KP_Left
1170     { KSYM_KP_Left,     "XK_KP_Left",           "keypad left" },
1171     { KSYM_KP_Right,    "XK_KP_Right",          "keypad right" },
1172     { KSYM_KP_Up,       "XK_KP_Up",             "keypad up" },
1173     { KSYM_KP_Down,     "XK_KP_Down",           "keypad down" },
1174 #endif
1175
1176     /* other keypad keys */
1177 #ifdef KSYM_KP_Enter
1178     { KSYM_KP_Enter,    "XK_KP_Enter",          "keypad enter" },
1179     { KSYM_KP_Add,      "XK_KP_Add",            "keypad +" },
1180     { KSYM_KP_Subtract, "XK_KP_Subtract",       "keypad -" },
1181     { KSYM_KP_Multiply, "XK_KP_Multiply",       "keypad mltply" },
1182     { KSYM_KP_Divide,   "XK_KP_Divide",         "keypad /" },
1183     { KSYM_KP_Separator,"XK_KP_Separator",      "keypad ," },
1184 #endif
1185
1186     /* modifier keys */
1187     { KSYM_Shift_L,     "XK_Shift_L",           "left shift" },
1188     { KSYM_Shift_R,     "XK_Shift_R",           "right shift" },
1189     { KSYM_Control_L,   "XK_Control_L",         "left control" },
1190     { KSYM_Control_R,   "XK_Control_R",         "right control" },
1191     { KSYM_Meta_L,      "XK_Meta_L",            "left meta" },
1192     { KSYM_Meta_R,      "XK_Meta_R",            "right meta" },
1193     { KSYM_Alt_L,       "XK_Alt_L",             "left alt" },
1194     { KSYM_Alt_R,       "XK_Alt_R",             "right alt" },
1195     { KSYM_Super_L,     "XK_Super_L",           "left super" },  /* Win-L */
1196     { KSYM_Super_R,     "XK_Super_R",           "right super" }, /* Win-R */
1197     { KSYM_Mode_switch, "XK_Mode_switch",       "mode switch" }, /* Alt-R */
1198     { KSYM_Multi_key,   "XK_Multi_key",         "multi key" },   /* Ctrl-R */
1199
1200     /* some special keys */
1201     { KSYM_BackSpace,   "XK_BackSpace",         "backspace" },
1202     { KSYM_Delete,      "XK_Delete",            "delete" },
1203     { KSYM_Insert,      "XK_Insert",            "insert" },
1204     { KSYM_Tab,         "XK_Tab",               "tab" },
1205     { KSYM_Home,        "XK_Home",              "home" },
1206     { KSYM_End,         "XK_End",               "end" },
1207     { KSYM_Page_Up,     "XK_Page_Up",           "page up" },
1208     { KSYM_Page_Down,   "XK_Page_Down",         "page down" },
1209     { KSYM_Menu,        "XK_Menu",              "menu" },        /* Win-Menu */
1210
1211     /* ASCII 0x20 to 0x40 keys (except numbers) */
1212     { KSYM_space,       "XK_space",             "space" },
1213     { KSYM_exclam,      "XK_exclam",            "!" },
1214     { KSYM_quotedbl,    "XK_quotedbl",          "\"" },
1215     { KSYM_numbersign,  "XK_numbersign",        "#" },
1216     { KSYM_dollar,      "XK_dollar",            "$" },
1217     { KSYM_percent,     "XK_percent",           "%" },
1218     { KSYM_ampersand,   "XK_ampersand",         "&" },
1219     { KSYM_apostrophe,  "XK_apostrophe",        "'" },
1220     { KSYM_parenleft,   "XK_parenleft",         "(" },
1221     { KSYM_parenright,  "XK_parenright",        ")" },
1222     { KSYM_asterisk,    "XK_asterisk",          "*" },
1223     { KSYM_plus,        "XK_plus",              "+" },
1224     { KSYM_comma,       "XK_comma",             "," },
1225     { KSYM_minus,       "XK_minus",             "-" },
1226     { KSYM_period,      "XK_period",            "." },
1227     { KSYM_slash,       "XK_slash",             "/" },
1228     { KSYM_colon,       "XK_colon",             ":" },
1229     { KSYM_semicolon,   "XK_semicolon",         ";" },
1230     { KSYM_less,        "XK_less",              "<" },
1231     { KSYM_equal,       "XK_equal",             "=" },
1232     { KSYM_greater,     "XK_greater",           ">" },
1233     { KSYM_question,    "XK_question",          "?" },
1234     { KSYM_at,          "XK_at",                "@" },
1235
1236     /* more ASCII keys */
1237     { KSYM_bracketleft, "XK_bracketleft",       "[" },
1238     { KSYM_backslash,   "XK_backslash",         "\\" },
1239     { KSYM_bracketright,"XK_bracketright",      "]" },
1240     { KSYM_asciicircum, "XK_asciicircum",       "^" },
1241     { KSYM_underscore,  "XK_underscore",        "_" },
1242     { KSYM_grave,       "XK_grave",             "grave" },
1243     { KSYM_quoteleft,   "XK_quoteleft",         "quote left" },
1244     { KSYM_braceleft,   "XK_braceleft",         "brace left" },
1245     { KSYM_bar,         "XK_bar",               "bar" },
1246     { KSYM_braceright,  "XK_braceright",        "brace right" },
1247     { KSYM_asciitilde,  "XK_asciitilde",        "~" },
1248
1249     /* special (non-ASCII) keys */
1250     { KSYM_degree,      "XK_degree",            "°" },
1251     { KSYM_Adiaeresis,  "XK_Adiaeresis",        "Ä" },
1252     { KSYM_Odiaeresis,  "XK_Odiaeresis",        "Ö" },
1253     { KSYM_Udiaeresis,  "XK_Udiaeresis",        "Ü" },
1254     { KSYM_adiaeresis,  "XK_adiaeresis",        "ä" },
1255     { KSYM_odiaeresis,  "XK_odiaeresis",        "ö" },
1256     { KSYM_udiaeresis,  "XK_udiaeresis",        "ü" },
1257     { KSYM_ssharp,      "XK_ssharp",            "sharp s" },
1258
1259     /* end-of-array identifier */
1260     { 0,                NULL,                   NULL }
1261   };
1262
1263   int i;
1264
1265   if (mode == TRANSLATE_KEYSYM_TO_KEYNAME)
1266   {
1267     static char name_buffer[30];
1268     Key key = *keysym;
1269
1270     if (key >= KSYM_A && key <= KSYM_Z)
1271       sprintf(name_buffer, "%c", 'A' + (char)(key - KSYM_A));
1272     else if (key >= KSYM_a && key <= KSYM_z)
1273       sprintf(name_buffer, "%c", 'a' + (char)(key - KSYM_a));
1274     else if (key >= KSYM_0 && key <= KSYM_9)
1275       sprintf(name_buffer, "%c", '0' + (char)(key - KSYM_0));
1276     else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
1277       sprintf(name_buffer, "keypad %c", '0' + (char)(key - KSYM_KP_0));
1278     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
1279       sprintf(name_buffer, "F%d", (int)(key - KSYM_FKEY_FIRST + 1));
1280     else if (key == KSYM_UNDEFINED)
1281       strcpy(name_buffer, "(undefined)");
1282     else
1283     {
1284       i = 0;
1285
1286       do
1287       {
1288         if (key == translate_key[i].key)
1289         {
1290           strcpy(name_buffer, translate_key[i].name);
1291           break;
1292         }
1293       }
1294       while (translate_key[++i].name);
1295
1296       if (!translate_key[i].name)
1297         strcpy(name_buffer, "(unknown)");
1298     }
1299
1300     *name = name_buffer;
1301   }
1302   else if (mode == TRANSLATE_KEYSYM_TO_X11KEYNAME)
1303   {
1304     static char name_buffer[30];
1305     Key key = *keysym;
1306
1307     if (key >= KSYM_A && key <= KSYM_Z)
1308       sprintf(name_buffer, "XK_%c", 'A' + (char)(key - KSYM_A));
1309     else if (key >= KSYM_a && key <= KSYM_z)
1310       sprintf(name_buffer, "XK_%c", 'a' + (char)(key - KSYM_a));
1311     else if (key >= KSYM_0 && key <= KSYM_9)
1312       sprintf(name_buffer, "XK_%c", '0' + (char)(key - KSYM_0));
1313     else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
1314       sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - KSYM_KP_0));
1315     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
1316       sprintf(name_buffer, "XK_F%d", (int)(key - KSYM_FKEY_FIRST + 1));
1317     else if (key == KSYM_UNDEFINED)
1318       strcpy(name_buffer, "[undefined]");
1319     else
1320     {
1321       i = 0;
1322
1323       do
1324       {
1325         if (key == translate_key[i].key)
1326         {
1327           strcpy(name_buffer, translate_key[i].x11name);
1328           break;
1329         }
1330       }
1331       while (translate_key[++i].x11name);
1332
1333       if (!translate_key[i].x11name)
1334         sprintf(name_buffer, "0x%04lx", (unsigned long)key);
1335     }
1336
1337     *x11name = name_buffer;
1338   }
1339   else if (mode == TRANSLATE_KEYNAME_TO_KEYSYM)
1340   {
1341     Key key = KSYM_UNDEFINED;
1342
1343     i = 0;
1344     do
1345     {
1346       if (strEqual(translate_key[i].name, *name))
1347       {
1348         key = translate_key[i].key;
1349         break;
1350       }
1351     }
1352     while (translate_key[++i].x11name);
1353
1354     if (key == KSYM_UNDEFINED)
1355       Error(ERR_WARN, "getKeyFromKeyName(): not completely implemented");
1356
1357     *keysym = key;
1358   }
1359   else if (mode == TRANSLATE_X11KEYNAME_TO_KEYSYM)
1360   {
1361     Key key = KSYM_UNDEFINED;
1362     char *name_ptr = *x11name;
1363
1364     if (strncmp(name_ptr, "XK_", 3) == 0 && strlen(name_ptr) == 4)
1365     {
1366       char c = name_ptr[3];
1367
1368       if (c >= 'A' && c <= 'Z')
1369         key = KSYM_A + (Key)(c - 'A');
1370       else if (c >= 'a' && c <= 'z')
1371         key = KSYM_a + (Key)(c - 'a');
1372       else if (c >= '0' && c <= '9')
1373         key = KSYM_0 + (Key)(c - '0');
1374     }
1375     else if (strncmp(name_ptr, "XK_KP_", 6) == 0 && strlen(name_ptr) == 7)
1376     {
1377       char c = name_ptr[6];
1378
1379       if (c >= '0' && c <= '9')
1380         key = KSYM_KP_0 + (Key)(c - '0');
1381     }
1382     else if (strncmp(name_ptr, "XK_F", 4) == 0 && strlen(name_ptr) <= 6)
1383     {
1384       char c1 = name_ptr[4];
1385       char c2 = name_ptr[5];
1386       int d = 0;
1387
1388       if ((c1 >= '0' && c1 <= '9') &&
1389           ((c2 >= '0' && c1 <= '9') || c2 == '\0'))
1390         d = atoi(&name_ptr[4]);
1391
1392       if (d >= 1 && d <= KSYM_NUM_FKEYS)
1393         key = KSYM_F1 + (Key)(d - 1);
1394     }
1395     else if (strncmp(name_ptr, "XK_", 3) == 0)
1396     {
1397       i = 0;
1398
1399       do
1400       {
1401         if (strEqual(name_ptr, translate_key[i].x11name))
1402         {
1403           key = translate_key[i].key;
1404           break;
1405         }
1406       }
1407       while (translate_key[++i].x11name);
1408     }
1409     else if (strncmp(name_ptr, "0x", 2) == 0)
1410     {
1411       unsigned long value = 0;
1412
1413       name_ptr += 2;
1414
1415       while (name_ptr)
1416       {
1417         char c = *name_ptr++;
1418         int d = -1;
1419
1420         if (c >= '0' && c <= '9')
1421           d = (int)(c - '0');
1422         else if (c >= 'a' && c <= 'f')
1423           d = (int)(c - 'a' + 10);
1424         else if (c >= 'A' && c <= 'F')
1425           d = (int)(c - 'A' + 10);
1426
1427         if (d == -1)
1428         {
1429           value = -1;
1430           break;
1431         }
1432
1433         value = value * 16 + d;
1434       }
1435
1436       if (value != -1)
1437         key = (Key)value;
1438     }
1439
1440     *keysym = key;
1441   }
1442 }
1443
1444 char *getKeyNameFromKey(Key key)
1445 {
1446   char *name;
1447
1448   translate_keyname(&key, NULL, &name, TRANSLATE_KEYSYM_TO_KEYNAME);
1449   return name;
1450 }
1451
1452 char *getX11KeyNameFromKey(Key key)
1453 {
1454   char *x11name;
1455
1456   translate_keyname(&key, &x11name, NULL, TRANSLATE_KEYSYM_TO_X11KEYNAME);
1457   return x11name;
1458 }
1459
1460 Key getKeyFromKeyName(char *name)
1461 {
1462   Key key;
1463
1464   translate_keyname(&key, NULL, &name, TRANSLATE_KEYNAME_TO_KEYSYM);
1465   return key;
1466 }
1467
1468 Key getKeyFromX11KeyName(char *x11name)
1469 {
1470   Key key;
1471
1472   translate_keyname(&key, &x11name, NULL, TRANSLATE_X11KEYNAME_TO_KEYSYM);
1473   return key;
1474 }
1475
1476 char getCharFromKey(Key key)
1477 {
1478   char *keyname = getKeyNameFromKey(key);
1479   char c = 0;
1480
1481   if (strlen(keyname) == 1)
1482     c = keyname[0];
1483   else if (strEqual(keyname, "space"))
1484     c = ' ';
1485
1486   return c;
1487 }
1488
1489 char getValidConfigValueChar(char c)
1490 {
1491   if (c == '#' ||       /* used to mark comments */
1492       c == '\\')        /* used to mark continued lines */
1493     c = 0;
1494
1495   return c;
1496 }
1497
1498
1499 /* ------------------------------------------------------------------------- */
1500 /* functions to translate string identifiers to integer or boolean value     */
1501 /* ------------------------------------------------------------------------- */
1502
1503 int get_integer_from_string(char *s)
1504 {
1505   static char *number_text[][3] =
1506   {
1507     { "0",      "zero",         "null",         },
1508     { "1",      "one",          "first"         },
1509     { "2",      "two",          "second"        },
1510     { "3",      "three",        "third"         },
1511     { "4",      "four",         "fourth"        },
1512     { "5",      "five",         "fifth"         },
1513     { "6",      "six",          "sixth"         },
1514     { "7",      "seven",        "seventh"       },
1515     { "8",      "eight",        "eighth"        },
1516     { "9",      "nine",         "ninth"         },
1517     { "10",     "ten",          "tenth"         },
1518     { "11",     "eleven",       "eleventh"      },
1519     { "12",     "twelve",       "twelfth"       },
1520
1521     { NULL,     NULL,           NULL            },
1522   };
1523
1524   int i, j;
1525   char *s_lower = getStringToLower(s);
1526   int result = -1;
1527
1528   for (i = 0; number_text[i][0] != NULL; i++)
1529     for (j = 0; j < 3; j++)
1530       if (strEqual(s_lower, number_text[i][j]))
1531         result = i;
1532
1533   if (result == -1)
1534   {
1535     if (strEqual(s_lower, "false"))
1536       result = 0;
1537     else if (strEqual(s_lower, "true"))
1538       result = 1;
1539     else
1540       result = atoi(s);
1541   }
1542
1543   free(s_lower);
1544
1545   return result;
1546 }
1547
1548 boolean get_boolean_from_string(char *s)
1549 {
1550   char *s_lower = getStringToLower(s);
1551   boolean result = FALSE;
1552
1553   if (strEqual(s_lower, "true") ||
1554       strEqual(s_lower, "yes") ||
1555       strEqual(s_lower, "on") ||
1556       get_integer_from_string(s) == 1)
1557     result = TRUE;
1558
1559   free(s_lower);
1560
1561   return result;
1562 }
1563
1564
1565 /* ------------------------------------------------------------------------- */
1566 /* functions for generic lists                                               */
1567 /* ------------------------------------------------------------------------- */
1568
1569 ListNode *newListNode()
1570 {
1571   return checked_calloc(sizeof(ListNode));
1572 }
1573
1574 void addNodeToList(ListNode **node_first, char *key, void *content)
1575 {
1576   ListNode *node_new = newListNode();
1577
1578   node_new->key = getStringCopy(key);
1579   node_new->content = content;
1580   node_new->next = *node_first;
1581   *node_first = node_new;
1582 }
1583
1584 void deleteNodeFromList(ListNode **node_first, char *key,
1585                         void (*destructor_function)(void *))
1586 {
1587   if (node_first == NULL || *node_first == NULL)
1588     return;
1589
1590   if (strEqual((*node_first)->key, key))
1591   {
1592     checked_free((*node_first)->key);
1593     if (destructor_function)
1594       destructor_function((*node_first)->content);
1595     *node_first = (*node_first)->next;
1596   }
1597   else
1598     deleteNodeFromList(&(*node_first)->next, key, destructor_function);
1599 }
1600
1601 ListNode *getNodeFromKey(ListNode *node_first, char *key)
1602 {
1603   if (node_first == NULL)
1604     return NULL;
1605
1606   if (strEqual(node_first->key, key))
1607     return node_first;
1608   else
1609     return getNodeFromKey(node_first->next, key);
1610 }
1611
1612 int getNumNodes(ListNode *node_first)
1613 {
1614   return (node_first ? 1 + getNumNodes(node_first->next) : 0);
1615 }
1616
1617 void dumpList(ListNode *node_first)
1618 {
1619   ListNode *node = node_first;
1620
1621   while (node)
1622   {
1623     printf("['%s' (%d)]\n", node->key,
1624            ((struct ListNodeInfo *)node->content)->num_references);
1625     node = node->next;
1626   }
1627
1628   printf("[%d nodes]\n", getNumNodes(node_first));
1629 }
1630
1631
1632 /* ------------------------------------------------------------------------- */
1633 /* functions for checking files and filenames                                */
1634 /* ------------------------------------------------------------------------- */
1635
1636 boolean fileExists(char *filename)
1637 {
1638   if (filename == NULL)
1639     return FALSE;
1640
1641   return (access(filename, F_OK) == 0);
1642 }
1643
1644 boolean fileHasPrefix(char *basename, char *prefix)
1645 {
1646   static char *basename_lower = NULL;
1647   int basename_length, prefix_length;
1648
1649   checked_free(basename_lower);
1650
1651   if (basename == NULL || prefix == NULL)
1652     return FALSE;
1653
1654   basename_lower = getStringToLower(basename);
1655   basename_length = strlen(basename_lower);
1656   prefix_length = strlen(prefix);
1657
1658   if (basename_length > prefix_length + 1 &&
1659       basename_lower[prefix_length] == '.' &&
1660       strncmp(basename_lower, prefix, prefix_length) == 0)
1661     return TRUE;
1662
1663   return FALSE;
1664 }
1665
1666 boolean fileHasSuffix(char *basename, char *suffix)
1667 {
1668   static char *basename_lower = NULL;
1669   int basename_length, suffix_length;
1670
1671   checked_free(basename_lower);
1672
1673   if (basename == NULL || suffix == NULL)
1674     return FALSE;
1675
1676   basename_lower = getStringToLower(basename);
1677   basename_length = strlen(basename_lower);
1678   suffix_length = strlen(suffix);
1679
1680   if (basename_length > suffix_length + 1 &&
1681       basename_lower[basename_length - suffix_length - 1] == '.' &&
1682       strEqual(&basename_lower[basename_length - suffix_length], suffix))
1683     return TRUE;
1684
1685   return FALSE;
1686 }
1687
1688 boolean FileIsGraphic(char *filename)
1689 {
1690   char *basename = getBaseNamePtr(filename);
1691
1692   return fileHasSuffix(basename, "pcx");
1693 }
1694
1695 boolean FileIsSound(char *filename)
1696 {
1697   char *basename = getBaseNamePtr(filename);
1698
1699   return fileHasSuffix(basename, "wav");
1700 }
1701
1702 boolean FileIsMusic(char *filename)
1703 {
1704   char *basename = getBaseNamePtr(filename);
1705
1706   if (FileIsSound(basename))
1707     return TRUE;
1708
1709 #if defined(TARGET_SDL)
1710   if (fileHasPrefix(basename, "mod") ||
1711       fileHasSuffix(basename, "mod") ||
1712       fileHasSuffix(basename, "s3m") ||
1713       fileHasSuffix(basename, "it") ||
1714       fileHasSuffix(basename, "xm") ||
1715       fileHasSuffix(basename, "midi") ||
1716       fileHasSuffix(basename, "mid") ||
1717       fileHasSuffix(basename, "mp3") ||
1718       fileHasSuffix(basename, "ogg"))
1719     return TRUE;
1720 #endif
1721
1722   return FALSE;
1723 }
1724
1725 boolean FileIsArtworkType(char *basename, int type)
1726 {
1727   if ((type == TREE_TYPE_GRAPHICS_DIR && FileIsGraphic(basename)) ||
1728       (type == TREE_TYPE_SOUNDS_DIR && FileIsSound(basename)) ||
1729       (type == TREE_TYPE_MUSIC_DIR && FileIsMusic(basename)))
1730     return TRUE;
1731
1732   return FALSE;
1733 }
1734
1735 /* ------------------------------------------------------------------------- */
1736 /* functions for loading artwork configuration information                   */
1737 /* ------------------------------------------------------------------------- */
1738
1739 char *get_mapped_token(char *token)
1740 {
1741   /* !!! make this dynamically configurable (init.c:InitArtworkConfig) !!! */
1742   static char *map_token_prefix[][2] =
1743   {
1744     { "char_procent",           "char_percent"  },
1745     { NULL,                                     }
1746   };
1747   int i;
1748
1749   for (i = 0; map_token_prefix[i][0] != NULL; i++)
1750   {
1751     int len_token_prefix = strlen(map_token_prefix[i][0]);
1752
1753     if (strncmp(token, map_token_prefix[i][0], len_token_prefix) == 0)
1754       return getStringCat2(map_token_prefix[i][1], &token[len_token_prefix]);
1755   }
1756
1757   return NULL;
1758 }
1759
1760 /* This function checks if a string <s> of the format "string1, string2, ..."
1761    exactly contains a string <s_contained>. */
1762
1763 static boolean string_has_parameter(char *s, char *s_contained)
1764 {
1765   char *substring;
1766
1767   if (s == NULL || s_contained == NULL)
1768     return FALSE;
1769
1770   if (strlen(s_contained) > strlen(s))
1771     return FALSE;
1772
1773   if (strncmp(s, s_contained, strlen(s_contained)) == 0)
1774   {
1775     char next_char = s[strlen(s_contained)];
1776
1777     /* check if next character is delimiter or whitespace */
1778     return (next_char == ',' || next_char == '\0' ||
1779             next_char == ' ' || next_char == '\t' ? TRUE : FALSE);
1780   }
1781
1782   /* check if string contains another parameter string after a comma */
1783   substring = strchr(s, ',');
1784   if (substring == NULL)        /* string does not contain a comma */
1785     return FALSE;
1786
1787   /* advance string pointer to next character after the comma */
1788   substring++;
1789
1790   /* skip potential whitespaces after the comma */
1791   while (*substring == ' ' || *substring == '\t')
1792     substring++;
1793
1794   return string_has_parameter(substring, s_contained);
1795 }
1796
1797 int get_parameter_value(char *value_raw, char *suffix, int type)
1798 {
1799   char *value = getStringToLower(value_raw);
1800   int result = 0;       /* probably a save default value */
1801
1802   if (strEqual(suffix, ".direction"))
1803   {
1804     result = (strEqual(value, "left")  ? MV_LEFT :
1805               strEqual(value, "right") ? MV_RIGHT :
1806               strEqual(value, "up")    ? MV_UP :
1807               strEqual(value, "down")  ? MV_DOWN : MV_NONE);
1808   }
1809   else if (strEqual(suffix, ".align"))
1810   {
1811     result = (strEqual(value, "left")   ? ALIGN_LEFT :
1812               strEqual(value, "right")  ? ALIGN_RIGHT :
1813               strEqual(value, "center") ? ALIGN_CENTER :
1814               strEqual(value, "middle") ? ALIGN_CENTER : ALIGN_DEFAULT);
1815   }
1816   else if (strEqual(suffix, ".valign"))
1817   {
1818     result = (strEqual(value, "top")    ? VALIGN_TOP :
1819               strEqual(value, "bottom") ? VALIGN_BOTTOM :
1820               strEqual(value, "middle") ? VALIGN_MIDDLE :
1821               strEqual(value, "center") ? VALIGN_MIDDLE : VALIGN_DEFAULT);
1822   }
1823   else if (strEqual(suffix, ".anim_mode"))
1824   {
1825     result = (string_has_parameter(value, "none")       ? ANIM_NONE :
1826               string_has_parameter(value, "loop")       ? ANIM_LOOP :
1827               string_has_parameter(value, "linear")     ? ANIM_LINEAR :
1828               string_has_parameter(value, "pingpong")   ? ANIM_PINGPONG :
1829               string_has_parameter(value, "pingpong2")  ? ANIM_PINGPONG2 :
1830               string_has_parameter(value, "random")     ? ANIM_RANDOM :
1831               string_has_parameter(value, "ce_value")   ? ANIM_CE_VALUE :
1832               string_has_parameter(value, "ce_score")   ? ANIM_CE_SCORE :
1833               string_has_parameter(value, "ce_delay")   ? ANIM_CE_DELAY :
1834               string_has_parameter(value, "horizontal") ? ANIM_HORIZONTAL :
1835               string_has_parameter(value, "vertical")   ? ANIM_VERTICAL :
1836               string_has_parameter(value, "centered")   ? ANIM_CENTERED :
1837               ANIM_DEFAULT);
1838
1839     if (string_has_parameter(value, "reverse"))
1840       result |= ANIM_REVERSE;
1841
1842     if (string_has_parameter(value, "opaque_player"))
1843       result |= ANIM_OPAQUE_PLAYER;
1844
1845     if (string_has_parameter(value, "static_panel"))
1846       result |= ANIM_STATIC_PANEL;
1847   }
1848   else if (strEqual(suffix, ".fade_mode"))
1849   {
1850     result = (string_has_parameter(value, "none")       ? FADE_MODE_NONE :
1851               string_has_parameter(value, "fade")       ? FADE_MODE_FADE :
1852               string_has_parameter(value, "crossfade")  ? FADE_MODE_CROSSFADE :
1853               string_has_parameter(value, "melt")       ? FADE_MODE_MELT :
1854               FADE_MODE_DEFAULT);
1855   }
1856   else if (strEqualN(suffix, ".font", 5))       /* (may also be ".font_xyz") */
1857   {
1858     result = gfx.get_font_from_token_function(value);
1859   }
1860   else          /* generic parameter of type integer or boolean */
1861   {
1862     result = (strEqual(value, ARG_UNDEFINED) ? ARG_UNDEFINED_VALUE :
1863               type == TYPE_INTEGER ? get_integer_from_string(value) :
1864               type == TYPE_BOOLEAN ? get_boolean_from_string(value) :
1865               ARG_UNDEFINED_VALUE);
1866   }
1867
1868   free(value);
1869
1870   return result;
1871 }
1872
1873 int get_token_parameter_value(char *token, char *value_raw)
1874 {
1875   char *suffix;
1876
1877   if (token == NULL || value_raw == NULL)
1878     return ARG_UNDEFINED_VALUE;
1879
1880   suffix = strrchr(token, '.');
1881   if (suffix == NULL)
1882     suffix = token;
1883
1884 #if 0
1885   if (strncmp(suffix, ".font", 5) == 0)
1886   {
1887     int i;
1888
1889     /* !!! OPTIMIZE THIS BY USING HASH !!! */
1890     for (i = 0; i < NUM_FONTS; i++)
1891       if (strEqual(value_raw, font_info[i].token_name))
1892         return i;
1893
1894     /* if font not found, use reliable default value */
1895     return FONT_INITIAL_1;
1896   }
1897 #endif
1898
1899   return get_parameter_value(value_raw, suffix, TYPE_INTEGER);
1900 }
1901
1902 struct ScreenModeInfo *get_screen_mode_from_string(char *screen_mode_string)
1903 {
1904   static struct ScreenModeInfo screen_mode;
1905   char *screen_mode_string_x = strchr(screen_mode_string, 'x');
1906   char *screen_mode_string_copy;
1907   char *screen_mode_string_pos_w;
1908   char *screen_mode_string_pos_h;
1909
1910   if (screen_mode_string_x == NULL)     /* invalid screen mode format */
1911     return NULL;
1912
1913   screen_mode_string_copy = getStringCopy(screen_mode_string);
1914
1915   screen_mode_string_pos_w = screen_mode_string_copy;
1916   screen_mode_string_pos_h = strchr(screen_mode_string_copy, 'x');
1917   *screen_mode_string_pos_h++ = '\0';
1918
1919   screen_mode.width  = atoi(screen_mode_string_pos_w);
1920   screen_mode.height = atoi(screen_mode_string_pos_h);
1921
1922   return &screen_mode;
1923 }
1924
1925 void get_aspect_ratio_from_screen_mode(struct ScreenModeInfo *screen_mode,
1926                                        int *x, int *y)
1927 {
1928   float aspect_ratio = (float)screen_mode->width / (float)screen_mode->height;
1929   float aspect_ratio_new;
1930   int i = 1;
1931
1932   do
1933   {
1934     *x = i * aspect_ratio + 0.000001;
1935     *y = i;
1936
1937     aspect_ratio_new = (float)*x / (float)*y;
1938
1939     i++;
1940   }
1941   while (aspect_ratio_new != aspect_ratio && *y < screen_mode->height);
1942 }
1943
1944 static void FreeCustomArtworkList(struct ArtworkListInfo *,
1945                                   struct ListNodeInfo ***, int *);
1946
1947 struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
1948                                            struct ConfigTypeInfo *suffix_list,
1949                                            char **ignore_tokens,
1950                                            int num_file_list_entries)
1951 {
1952   struct FileInfo *file_list;
1953   int num_file_list_entries_found = 0;
1954   int num_suffix_list_entries = 0;
1955   int list_pos;
1956   int i, j;
1957
1958   file_list = checked_calloc(num_file_list_entries * sizeof(struct FileInfo));
1959
1960   for (i = 0; suffix_list[i].token != NULL; i++)
1961     num_suffix_list_entries++;
1962
1963   /* always start with reliable default values */
1964   for (i = 0; i < num_file_list_entries; i++)
1965   {
1966     file_list[i].token = NULL;
1967
1968     file_list[i].default_filename = NULL;
1969     file_list[i].filename = NULL;
1970
1971     if (num_suffix_list_entries > 0)
1972     {
1973       int parameter_array_size = num_suffix_list_entries * sizeof(char *);
1974
1975       file_list[i].default_parameter = checked_calloc(parameter_array_size);
1976       file_list[i].parameter = checked_calloc(parameter_array_size);
1977
1978       for (j = 0; j < num_suffix_list_entries; j++)
1979       {
1980         setString(&file_list[i].default_parameter[j], suffix_list[j].value);
1981         setString(&file_list[i].parameter[j], suffix_list[j].value);
1982       }
1983
1984       file_list[i].redefined = FALSE;
1985       file_list[i].fallback_to_default = FALSE;
1986     }
1987   }
1988
1989   list_pos = 0;
1990   for (i = 0; config_list[i].token != NULL; i++)
1991   {
1992     int len_config_token = strlen(config_list[i].token);
1993     int len_config_value = strlen(config_list[i].value);
1994     boolean is_file_entry = TRUE;
1995
1996     for (j = 0; suffix_list[j].token != NULL; j++)
1997     {
1998       int len_suffix = strlen(suffix_list[j].token);
1999
2000       if (len_suffix < len_config_token &&
2001           strEqual(&config_list[i].token[len_config_token - len_suffix],
2002                    suffix_list[j].token))
2003       {
2004         setString(&file_list[list_pos].default_parameter[j],
2005                   config_list[i].value);
2006
2007         is_file_entry = FALSE;
2008         break;
2009       }
2010     }
2011
2012     /* the following tokens are no file definitions, but other config tokens */
2013     for (j = 0; ignore_tokens[j] != NULL; j++)
2014       if (strEqual(config_list[i].token, ignore_tokens[j]))
2015         is_file_entry = FALSE;
2016
2017     if (is_file_entry)
2018     {
2019       if (i > 0)
2020         list_pos++;
2021
2022       if (list_pos >= num_file_list_entries)
2023         break;
2024
2025       /* simple sanity check if this is really a file definition */
2026       if (!strEqual(&config_list[i].value[len_config_value - 4], ".pcx") &&
2027           !strEqual(&config_list[i].value[len_config_value - 4], ".wav") &&
2028           !strEqual(config_list[i].value, UNDEFINED_FILENAME))
2029       {
2030         Error(ERR_INFO, "Configuration directive '%s' -> '%s':",
2031               config_list[i].token, config_list[i].value);
2032         Error(ERR_EXIT, "This seems to be no valid definition -- please fix");
2033       }
2034
2035       file_list[list_pos].token = config_list[i].token;
2036       file_list[list_pos].default_filename = config_list[i].value;
2037
2038 #if 0
2039       printf("::: '%s' => '%s'\n", config_list[i].token, config_list[i].value);
2040 #endif
2041     }
2042   }
2043
2044   num_file_list_entries_found = list_pos + 1;
2045   if (num_file_list_entries_found != num_file_list_entries)
2046   {
2047     Error(ERR_INFO_LINE, "-");
2048     Error(ERR_INFO, "inconsistant config list information:");
2049     Error(ERR_INFO, "- should be:   %d (according to 'src/conf_xxx.h')",
2050           num_file_list_entries);
2051     Error(ERR_INFO, "- found to be: %d (according to 'src/conf_xxx.c')",
2052           num_file_list_entries_found);
2053     Error(ERR_EXIT,   "please fix");
2054   }
2055
2056 #if 0
2057   printf("::: ---------- DONE ----------\n");
2058 #endif
2059
2060   return file_list;
2061 }
2062
2063 static boolean token_suffix_match(char *token, char *suffix, int start_pos)
2064 {
2065   int len_token = strlen(token);
2066   int len_suffix = strlen(suffix);
2067
2068   if (start_pos < 0)    /* compare suffix from end of string */
2069     start_pos += len_token;
2070
2071   if (start_pos < 0 || start_pos + len_suffix > len_token)
2072     return FALSE;
2073
2074   if (strncmp(&token[start_pos], suffix, len_suffix) != 0)
2075     return FALSE;
2076
2077   if (token[start_pos + len_suffix] == '\0')
2078     return TRUE;
2079
2080   if (token[start_pos + len_suffix] == '.')
2081     return TRUE;
2082
2083   return FALSE;
2084 }
2085
2086 #define KNOWN_TOKEN_VALUE       "[KNOWN_TOKEN_VALUE]"
2087
2088 static void read_token_parameters(SetupFileHash *setup_file_hash,
2089                                   struct ConfigTypeInfo *suffix_list,
2090                                   struct FileInfo *file_list_entry)
2091 {
2092   /* check for config token that is the base token without any suffixes */
2093   char *filename = getHashEntry(setup_file_hash, file_list_entry->token);
2094   char *known_token_value = KNOWN_TOKEN_VALUE;
2095   int i;
2096
2097   if (filename != NULL)
2098   {
2099     setString(&file_list_entry->filename, filename);
2100
2101     /* when file definition found, set all parameters to default values */
2102     for (i = 0; suffix_list[i].token != NULL; i++)
2103       setString(&file_list_entry->parameter[i], suffix_list[i].value);
2104
2105     file_list_entry->redefined = TRUE;
2106
2107     /* mark config file token as well known from default config */
2108     setHashEntry(setup_file_hash, file_list_entry->token, known_token_value);
2109   }
2110
2111   /* check for config tokens that can be build by base token and suffixes */
2112   for (i = 0; suffix_list[i].token != NULL; i++)
2113   {
2114     char *token = getStringCat2(file_list_entry->token, suffix_list[i].token);
2115     char *value = getHashEntry(setup_file_hash, token);
2116
2117     if (value != NULL)
2118     {
2119       setString(&file_list_entry->parameter[i], value);
2120
2121       /* mark config file token as well known from default config */
2122       setHashEntry(setup_file_hash, token, known_token_value);
2123     }
2124
2125     free(token);
2126   }
2127 }
2128
2129 static void add_dynamic_file_list_entry(struct FileInfo **list,
2130                                         int *num_list_entries,
2131                                         SetupFileHash *extra_file_hash,
2132                                         struct ConfigTypeInfo *suffix_list,
2133                                         int num_suffix_list_entries,
2134                                         char *token)
2135 {
2136   struct FileInfo *new_list_entry;
2137   int parameter_array_size = num_suffix_list_entries * sizeof(char *);
2138
2139   (*num_list_entries)++;
2140   *list = checked_realloc(*list, *num_list_entries * sizeof(struct FileInfo));
2141   new_list_entry = &(*list)[*num_list_entries - 1];
2142
2143   new_list_entry->token = getStringCopy(token);
2144   new_list_entry->default_filename = NULL;
2145   new_list_entry->filename = NULL;
2146   new_list_entry->parameter = checked_calloc(parameter_array_size);
2147
2148   new_list_entry->redefined = FALSE;
2149   new_list_entry->fallback_to_default = FALSE;
2150
2151   read_token_parameters(extra_file_hash, suffix_list, new_list_entry);
2152 }
2153
2154 static void add_property_mapping(struct PropertyMapping **list,
2155                                  int *num_list_entries,
2156                                  int base_index, int ext1_index,
2157                                  int ext2_index, int ext3_index,
2158                                  int artwork_index)
2159 {
2160   struct PropertyMapping *new_list_entry;
2161
2162   (*num_list_entries)++;
2163   *list = checked_realloc(*list,
2164                           *num_list_entries * sizeof(struct PropertyMapping));
2165   new_list_entry = &(*list)[*num_list_entries - 1];
2166
2167   new_list_entry->base_index = base_index;
2168   new_list_entry->ext1_index = ext1_index;
2169   new_list_entry->ext2_index = ext2_index;
2170   new_list_entry->ext3_index = ext3_index;
2171
2172   new_list_entry->artwork_index = artwork_index;
2173 }
2174
2175 static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
2176                                           char *filename)
2177 {
2178   struct FileInfo *file_list = artwork_info->file_list;
2179   struct ConfigTypeInfo *suffix_list = artwork_info->suffix_list;
2180   char **base_prefixes = artwork_info->base_prefixes;
2181   char **ext1_suffixes = artwork_info->ext1_suffixes;
2182   char **ext2_suffixes = artwork_info->ext2_suffixes;
2183   char **ext3_suffixes = artwork_info->ext3_suffixes;
2184   char **ignore_tokens = artwork_info->ignore_tokens;
2185   int num_file_list_entries = artwork_info->num_file_list_entries;
2186   int num_suffix_list_entries = artwork_info->num_suffix_list_entries;
2187   int num_base_prefixes = artwork_info->num_base_prefixes;
2188   int num_ext1_suffixes = artwork_info->num_ext1_suffixes;
2189   int num_ext2_suffixes = artwork_info->num_ext2_suffixes;
2190   int num_ext3_suffixes = artwork_info->num_ext3_suffixes;
2191   int num_ignore_tokens = artwork_info->num_ignore_tokens;
2192   SetupFileHash *setup_file_hash, *valid_file_hash;
2193   SetupFileHash *extra_file_hash, *empty_file_hash;
2194   char *known_token_value = KNOWN_TOKEN_VALUE;
2195   int i, j, k, l;
2196
2197   if (filename == NULL)
2198     return;
2199
2200 #if 0
2201   printf("LoadArtworkConfigFromFilename '%s' ...\n", filename);
2202 #endif
2203
2204   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
2205     return;
2206
2207   /* separate valid (defined) from empty (undefined) config token values */
2208   valid_file_hash = newSetupFileHash();
2209   empty_file_hash = newSetupFileHash();
2210   BEGIN_HASH_ITERATION(setup_file_hash, itr)
2211   {
2212     char *value = HASH_ITERATION_VALUE(itr);
2213
2214     setHashEntry(*value ? valid_file_hash : empty_file_hash,
2215                  HASH_ITERATION_TOKEN(itr), value);
2216   }
2217   END_HASH_ITERATION(setup_file_hash, itr)
2218
2219   /* at this point, we do not need the setup file hash anymore -- free it */
2220   freeSetupFileHash(setup_file_hash);
2221
2222   /* map deprecated to current tokens (using prefix match and replace) */
2223   BEGIN_HASH_ITERATION(valid_file_hash, itr)
2224   {
2225     char *token = HASH_ITERATION_TOKEN(itr);
2226     char *mapped_token = get_mapped_token(token);
2227
2228     if (mapped_token != NULL)
2229     {
2230       char *value = HASH_ITERATION_VALUE(itr);
2231
2232       /* add mapped token */
2233       setHashEntry(valid_file_hash, mapped_token, value);
2234
2235       /* ignore old token (by setting it to "known" keyword) */
2236       setHashEntry(valid_file_hash, token, known_token_value);
2237
2238       free(mapped_token);
2239     }
2240   }
2241   END_HASH_ITERATION(valid_file_hash, itr)
2242
2243   /* read parameters for all known config file tokens */
2244   for (i = 0; i < num_file_list_entries; i++)
2245     read_token_parameters(valid_file_hash, suffix_list, &file_list[i]);
2246
2247   /* set all tokens that can be ignored here to "known" keyword */
2248   for (i = 0; i < num_ignore_tokens; i++)
2249     setHashEntry(valid_file_hash, ignore_tokens[i], known_token_value);
2250
2251   /* copy all unknown config file tokens to extra config hash */
2252   extra_file_hash = newSetupFileHash();
2253   BEGIN_HASH_ITERATION(valid_file_hash, itr)
2254   {
2255     char *value = HASH_ITERATION_VALUE(itr);
2256
2257     if (!strEqual(value, known_token_value))
2258       setHashEntry(extra_file_hash, HASH_ITERATION_TOKEN(itr), value);
2259   }
2260   END_HASH_ITERATION(valid_file_hash, itr)
2261
2262   /* at this point, we do not need the valid file hash anymore -- free it */
2263   freeSetupFileHash(valid_file_hash);
2264
2265   /* now try to determine valid, dynamically defined config tokens */
2266
2267   BEGIN_HASH_ITERATION(extra_file_hash, itr)
2268   {
2269     struct FileInfo **dynamic_file_list =
2270       &artwork_info->dynamic_file_list;
2271     int *num_dynamic_file_list_entries =
2272       &artwork_info->num_dynamic_file_list_entries;
2273     struct PropertyMapping **property_mapping =
2274       &artwork_info->property_mapping;
2275     int *num_property_mapping_entries =
2276       &artwork_info->num_property_mapping_entries;
2277     int current_summarized_file_list_entry =
2278       artwork_info->num_file_list_entries +
2279       artwork_info->num_dynamic_file_list_entries;
2280     char *token = HASH_ITERATION_TOKEN(itr);
2281     int len_token = strlen(token);
2282     int start_pos;
2283     boolean base_prefix_found = FALSE;
2284     boolean parameter_suffix_found = FALSE;
2285
2286 #if 0
2287     printf("::: examining '%s' -> '%s'\n", token, HASH_ITERATION_VALUE(itr));
2288 #endif
2289
2290     /* skip all parameter definitions (handled by read_token_parameters()) */
2291     for (i = 0; i < num_suffix_list_entries && !parameter_suffix_found; i++)
2292     {
2293       int len_suffix = strlen(suffix_list[i].token);
2294
2295       if (token_suffix_match(token, suffix_list[i].token, -len_suffix))
2296         parameter_suffix_found = TRUE;
2297     }
2298
2299     if (parameter_suffix_found)
2300       continue;
2301
2302     /* ---------- step 0: search for matching base prefix ---------- */
2303
2304     start_pos = 0;
2305     for (i = 0; i < num_base_prefixes && !base_prefix_found; i++)
2306     {
2307       char *base_prefix = base_prefixes[i];
2308       int len_base_prefix = strlen(base_prefix);
2309       boolean ext1_suffix_found = FALSE;
2310       boolean ext2_suffix_found = FALSE;
2311       boolean ext3_suffix_found = FALSE;
2312       boolean exact_match = FALSE;
2313       int base_index = -1;
2314       int ext1_index = -1;
2315       int ext2_index = -1;
2316       int ext3_index = -1;
2317
2318       base_prefix_found = token_suffix_match(token, base_prefix, start_pos);
2319
2320       if (!base_prefix_found)
2321         continue;
2322
2323       base_index = i;
2324
2325       if (start_pos + len_base_prefix == len_token)     /* exact match */
2326       {
2327         exact_match = TRUE;
2328
2329         add_dynamic_file_list_entry(dynamic_file_list,
2330                                     num_dynamic_file_list_entries,
2331                                     extra_file_hash,
2332                                     suffix_list,
2333                                     num_suffix_list_entries,
2334                                     token);
2335         add_property_mapping(property_mapping,
2336                              num_property_mapping_entries,
2337                              base_index, -1, -1, -1,
2338                              current_summarized_file_list_entry);
2339         continue;
2340       }
2341
2342 #if 0
2343       if (IS_PARENT_PROCESS())
2344         printf("---> examining token '%s': search 1st suffix ...\n", token);
2345 #endif
2346
2347       /* ---------- step 1: search for matching first suffix ---------- */
2348
2349       start_pos += len_base_prefix;
2350       for (j = 0; j < num_ext1_suffixes && !ext1_suffix_found; j++)
2351       {
2352         char *ext1_suffix = ext1_suffixes[j];
2353         int len_ext1_suffix = strlen(ext1_suffix);
2354
2355         ext1_suffix_found = token_suffix_match(token, ext1_suffix, start_pos);
2356
2357         if (!ext1_suffix_found)
2358           continue;
2359
2360         ext1_index = j;
2361
2362         if (start_pos + len_ext1_suffix == len_token)   /* exact match */
2363         {
2364           exact_match = TRUE;
2365
2366           add_dynamic_file_list_entry(dynamic_file_list,
2367                                       num_dynamic_file_list_entries,
2368                                       extra_file_hash,
2369                                       suffix_list,
2370                                       num_suffix_list_entries,
2371                                       token);
2372           add_property_mapping(property_mapping,
2373                                num_property_mapping_entries,
2374                                base_index, ext1_index, -1, -1,
2375                                current_summarized_file_list_entry);
2376           continue;
2377         }
2378
2379         start_pos += len_ext1_suffix;
2380       }
2381
2382       if (exact_match)
2383         break;
2384
2385 #if 0
2386       if (IS_PARENT_PROCESS())
2387         printf("---> examining token '%s': search 2nd suffix ...\n", token);
2388 #endif
2389
2390       /* ---------- step 2: search for matching second suffix ---------- */
2391
2392       for (k = 0; k < num_ext2_suffixes && !ext2_suffix_found; k++)
2393       {
2394         char *ext2_suffix = ext2_suffixes[k];
2395         int len_ext2_suffix = strlen(ext2_suffix);
2396
2397         ext2_suffix_found = token_suffix_match(token, ext2_suffix, start_pos);
2398
2399         if (!ext2_suffix_found)
2400           continue;
2401
2402         ext2_index = k;
2403
2404         if (start_pos + len_ext2_suffix == len_token)   /* exact match */
2405         {
2406           exact_match = TRUE;
2407
2408           add_dynamic_file_list_entry(dynamic_file_list,
2409                                       num_dynamic_file_list_entries,
2410                                       extra_file_hash,
2411                                       suffix_list,
2412                                       num_suffix_list_entries,
2413                                       token);
2414           add_property_mapping(property_mapping,
2415                                num_property_mapping_entries,
2416                                base_index, ext1_index, ext2_index, -1,
2417                                current_summarized_file_list_entry);
2418           continue;
2419         }
2420
2421         start_pos += len_ext2_suffix;
2422       }
2423
2424       if (exact_match)
2425         break;
2426
2427 #if 0
2428       if (IS_PARENT_PROCESS())
2429         printf("---> examining token '%s': search 3rd suffix ...\n",token);
2430 #endif
2431
2432       /* ---------- step 3: search for matching third suffix ---------- */
2433
2434       for (l = 0; l < num_ext3_suffixes && !ext3_suffix_found; l++)
2435       {
2436         char *ext3_suffix = ext3_suffixes[l];
2437         int len_ext3_suffix = strlen(ext3_suffix);
2438
2439         ext3_suffix_found = token_suffix_match(token, ext3_suffix, start_pos);
2440
2441         if (!ext3_suffix_found)
2442           continue;
2443
2444         ext3_index = l;
2445
2446         if (start_pos + len_ext3_suffix == len_token) /* exact match */
2447         {
2448           exact_match = TRUE;
2449
2450           add_dynamic_file_list_entry(dynamic_file_list,
2451                                       num_dynamic_file_list_entries,
2452                                       extra_file_hash,
2453                                       suffix_list,
2454                                       num_suffix_list_entries,
2455                                       token);
2456           add_property_mapping(property_mapping,
2457                                num_property_mapping_entries,
2458                                base_index, ext1_index, ext2_index, ext3_index,
2459                                current_summarized_file_list_entry);
2460           continue;
2461         }
2462       }
2463     }
2464   }
2465   END_HASH_ITERATION(extra_file_hash, itr)
2466
2467   if (artwork_info->num_dynamic_file_list_entries > 0)
2468   {
2469     artwork_info->dynamic_artwork_list =
2470       checked_calloc(artwork_info->num_dynamic_file_list_entries *
2471                      artwork_info->sizeof_artwork_list_entry);
2472   }
2473
2474   if (options.verbose && IS_PARENT_PROCESS())
2475   {
2476     SetupFileList *setup_file_list, *list;
2477     boolean dynamic_tokens_found = FALSE;
2478     boolean unknown_tokens_found = FALSE;
2479     boolean undefined_values_found = (hashtable_count(empty_file_hash) != 0);
2480
2481     if ((setup_file_list = loadSetupFileList(filename)) == NULL)
2482       Error(ERR_EXIT, "loadSetupFileHash works, but loadSetupFileList fails");
2483
2484     BEGIN_HASH_ITERATION(extra_file_hash, itr)
2485     {
2486       if (strEqual(HASH_ITERATION_VALUE(itr), known_token_value))
2487         dynamic_tokens_found = TRUE;
2488       else
2489         unknown_tokens_found = TRUE;
2490     }
2491     END_HASH_ITERATION(extra_file_hash, itr)
2492
2493     if (options.debug && dynamic_tokens_found)
2494     {
2495       Error(ERR_INFO_LINE, "-");
2496       Error(ERR_INFO, "dynamic token(s) found in config file:");
2497       Error(ERR_INFO, "- config file: '%s'", filename);
2498
2499       for (list = setup_file_list; list != NULL; list = list->next)
2500       {
2501         char *value = getHashEntry(extra_file_hash, list->token);
2502
2503         if (value != NULL && strEqual(value, known_token_value))
2504           Error(ERR_INFO, "- dynamic token: '%s'", list->token);
2505       }
2506
2507       Error(ERR_INFO_LINE, "-");
2508     }
2509
2510     if (unknown_tokens_found)
2511     {
2512       Error(ERR_INFO_LINE, "-");
2513       Error(ERR_INFO, "warning: unknown token(s) found in config file:");
2514       Error(ERR_INFO, "- config file: '%s'", filename);
2515
2516       for (list = setup_file_list; list != NULL; list = list->next)
2517       {
2518         char *value = getHashEntry(extra_file_hash, list->token);
2519
2520         if (value != NULL && !strEqual(value, known_token_value))
2521           Error(ERR_INFO, "- dynamic token: '%s'", list->token);
2522       }
2523
2524       Error(ERR_INFO_LINE, "-");
2525     }
2526
2527     if (undefined_values_found)
2528     {
2529       Error(ERR_INFO_LINE, "-");
2530       Error(ERR_INFO, "warning: undefined values found in config file:");
2531       Error(ERR_INFO, "- config file: '%s'", filename);
2532
2533       for (list = setup_file_list; list != NULL; list = list->next)
2534       {
2535         char *value = getHashEntry(empty_file_hash, list->token);
2536
2537         if (value != NULL)
2538           Error(ERR_INFO, "- undefined value for token: '%s'", list->token);
2539       }
2540
2541       Error(ERR_INFO_LINE, "-");
2542     }
2543
2544     freeSetupFileList(setup_file_list);
2545   }
2546
2547   freeSetupFileHash(extra_file_hash);
2548   freeSetupFileHash(empty_file_hash);
2549
2550 #if 0
2551   for (i = 0; i < num_file_list_entries; i++)
2552   {
2553     printf("'%s' ", file_list[i].token);
2554     if (file_list[i].filename)
2555       printf("-> '%s'\n", file_list[i].filename);
2556     else
2557       printf("-> UNDEFINED [-> '%s']\n", file_list[i].default_filename);
2558   }
2559 #endif
2560 }
2561
2562 void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
2563 {
2564   struct FileInfo *file_list = artwork_info->file_list;
2565   int num_file_list_entries = artwork_info->num_file_list_entries;
2566   int num_suffix_list_entries = artwork_info->num_suffix_list_entries;
2567   char *filename_base = UNDEFINED_FILENAME, *filename_local;
2568   int i, j;
2569
2570   DrawInitText("Loading artwork config", 120, FC_GREEN);
2571   DrawInitText(ARTWORKINFO_FILENAME(artwork_info->type), 150, FC_YELLOW);
2572
2573   /* always start with reliable default values */
2574   for (i = 0; i < num_file_list_entries; i++)
2575   {
2576     setString(&file_list[i].filename, file_list[i].default_filename);
2577
2578     for (j = 0; j < num_suffix_list_entries; j++)
2579       setString(&file_list[i].parameter[j], file_list[i].default_parameter[j]);
2580
2581     file_list[i].redefined = FALSE;
2582     file_list[i].fallback_to_default = FALSE;
2583   }
2584
2585   /* free previous dynamic artwork file array */
2586   if (artwork_info->dynamic_file_list != NULL)
2587   {
2588     for (i = 0; i < artwork_info->num_dynamic_file_list_entries; i++)
2589     {
2590       free(artwork_info->dynamic_file_list[i].token);
2591       free(artwork_info->dynamic_file_list[i].filename);
2592       free(artwork_info->dynamic_file_list[i].parameter);
2593     }
2594
2595     free(artwork_info->dynamic_file_list);
2596     artwork_info->dynamic_file_list = NULL;
2597
2598     FreeCustomArtworkList(artwork_info, &artwork_info->dynamic_artwork_list,
2599                           &artwork_info->num_dynamic_file_list_entries);
2600   }
2601
2602   /* free previous property mapping */
2603   if (artwork_info->property_mapping != NULL)
2604   {
2605     free(artwork_info->property_mapping);
2606
2607     artwork_info->property_mapping = NULL;
2608     artwork_info->num_property_mapping_entries = 0;
2609   }
2610
2611   if (!SETUP_OVERRIDE_ARTWORK(setup, artwork_info->type))
2612   {
2613     /* first look for special artwork configured in level series config */
2614     filename_base = getCustomArtworkLevelConfigFilename(artwork_info->type);
2615
2616     if (fileExists(filename_base))
2617       LoadArtworkConfigFromFilename(artwork_info, filename_base);
2618   }
2619
2620   filename_local = getCustomArtworkConfigFilename(artwork_info->type);
2621
2622   if (filename_local != NULL && !strEqual(filename_base, filename_local))
2623     LoadArtworkConfigFromFilename(artwork_info, filename_local);
2624 }
2625
2626 static void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
2627                                    struct ListNodeInfo **listnode)
2628 {
2629   if (*listnode)
2630   {
2631     char *filename = (*listnode)->source_filename;
2632
2633     if (--(*listnode)->num_references <= 0)
2634       deleteNodeFromList(&artwork_info->content_list, filename,
2635                          artwork_info->free_artwork);
2636
2637     *listnode = NULL;
2638   }
2639 }
2640
2641 static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
2642                                     struct ListNodeInfo **listnode,
2643                                     struct FileInfo *file_list_entry)
2644 {
2645   char *init_text[] =
2646   {
2647     "Loading graphics",
2648     "Loading sounds",
2649     "Loading music"
2650   };
2651
2652   ListNode *node;
2653   char *basename = file_list_entry->filename;
2654   char *filename = getCustomArtworkFilename(basename, artwork_info->type);
2655
2656   if (filename == NULL)
2657   {
2658     Error(ERR_WARN, "cannot find artwork file '%s'", basename);
2659
2660     basename = file_list_entry->default_filename;
2661
2662     /* dynamic artwork has no default filename / skip empty default artwork */
2663     if (basename == NULL || strEqual(basename, UNDEFINED_FILENAME))
2664       return;
2665
2666     file_list_entry->fallback_to_default = TRUE;
2667
2668     Error(ERR_WARN, "trying default artwork file '%s'", basename);
2669
2670     filename = getCustomArtworkFilename(basename, artwork_info->type);
2671
2672     if (filename == NULL)
2673     {
2674       int error_mode = ERR_WARN;
2675
2676       /* we can get away without sounds and music, but not without graphics */
2677       if (*listnode == NULL && artwork_info->type == ARTWORK_TYPE_GRAPHICS)
2678         error_mode = ERR_EXIT;
2679
2680       Error(error_mode, "cannot find default artwork file '%s'", basename);
2681
2682       return;
2683     }
2684   }
2685
2686   /* check if the old and the new artwork file are the same */
2687   if (*listnode && strEqual((*listnode)->source_filename, filename))
2688   {
2689     /* The old and new artwork are the same (have the same filename and path).
2690        This usually means that this artwork does not exist in this artwork set
2691        and a fallback to the existing artwork is done. */
2692
2693 #if 0
2694     printf("[artwork '%s' already exists (same list entry)]\n", filename);
2695 #endif
2696
2697     return;
2698   }
2699
2700   /* delete existing artwork file entry */
2701   deleteArtworkListEntry(artwork_info, listnode);
2702
2703   /* check if the new artwork file already exists in the list of artworks */
2704   if ((node = getNodeFromKey(artwork_info->content_list, filename)) != NULL)
2705   {
2706 #if 0
2707       printf("[artwork '%s' already exists (other list entry)]\n", filename);
2708 #endif
2709
2710       *listnode = (struct ListNodeInfo *)node->content;
2711       (*listnode)->num_references++;
2712
2713       return;
2714   }
2715
2716   DrawInitText(init_text[artwork_info->type], 120, FC_GREEN);
2717   DrawInitText(basename, 150, FC_YELLOW);
2718
2719   if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
2720   {
2721 #if 0
2722       printf("[adding new artwork '%s']\n", filename);
2723 #endif
2724
2725     (*listnode)->num_references = 1;
2726     addNodeToList(&artwork_info->content_list, (*listnode)->source_filename,
2727                   *listnode);
2728   }
2729   else
2730   {
2731     int error_mode = ERR_WARN;
2732
2733     /* we can get away without sounds and music, but not without graphics */
2734     if (artwork_info->type == ARTWORK_TYPE_GRAPHICS)
2735       error_mode = ERR_EXIT;
2736
2737     Error(error_mode, "cannot load artwork file '%s'", basename);
2738     return;
2739   }
2740 }
2741
2742 static void LoadCustomArtwork(struct ArtworkListInfo *artwork_info,
2743                               struct ListNodeInfo **listnode,
2744                               struct FileInfo *file_list_entry)
2745 {
2746 #if 0
2747   printf("GOT CUSTOM ARTWORK FILE '%s'\n", file_list_entry->filename);
2748 #endif
2749
2750   if (strEqual(file_list_entry->filename, UNDEFINED_FILENAME))
2751   {
2752     deleteArtworkListEntry(artwork_info, listnode);
2753     return;
2754   }
2755
2756   replaceArtworkListEntry(artwork_info, listnode, file_list_entry);
2757 }
2758
2759 void ReloadCustomArtworkList(struct ArtworkListInfo *artwork_info)
2760 {
2761   struct FileInfo *file_list = artwork_info->file_list;
2762   struct FileInfo *dynamic_file_list = artwork_info->dynamic_file_list;
2763   int num_file_list_entries = artwork_info->num_file_list_entries;
2764   int num_dynamic_file_list_entries =
2765     artwork_info->num_dynamic_file_list_entries;
2766   int i;
2767
2768   for (i = 0; i < num_file_list_entries; i++)
2769     LoadCustomArtwork(artwork_info, &artwork_info->artwork_list[i],
2770                       &file_list[i]);
2771
2772   for (i = 0; i < num_dynamic_file_list_entries; i++)
2773     LoadCustomArtwork(artwork_info, &artwork_info->dynamic_artwork_list[i],
2774                       &dynamic_file_list[i]);
2775
2776 #if 0
2777   dumpList(artwork_info->content_list);
2778 #endif
2779 }
2780
2781 static void FreeCustomArtworkList(struct ArtworkListInfo *artwork_info,
2782                                   struct ListNodeInfo ***list,
2783                                   int *num_list_entries)
2784 {
2785   int i;
2786
2787   if (*list == NULL)
2788     return;
2789
2790   for (i = 0; i < *num_list_entries; i++)
2791     deleteArtworkListEntry(artwork_info, &(*list)[i]);
2792   free(*list);
2793
2794   *list = NULL;
2795   *num_list_entries = 0;
2796 }
2797
2798 void FreeCustomArtworkLists(struct ArtworkListInfo *artwork_info)
2799 {
2800   if (artwork_info == NULL)
2801     return;
2802
2803   FreeCustomArtworkList(artwork_info, &artwork_info->artwork_list,
2804                         &artwork_info->num_file_list_entries);
2805
2806   FreeCustomArtworkList(artwork_info, &artwork_info->dynamic_artwork_list,
2807                         &artwork_info->num_dynamic_file_list_entries);
2808 }
2809
2810
2811 /* ------------------------------------------------------------------------- */
2812 /* functions only needed for non-Unix (non-command-line) systems             */
2813 /* (MS-DOS only; SDL/Windows creates files "stdout.txt" and "stderr.txt")    */
2814 /* (now also added for Windows, to create files in user data directory)      */
2815 /* ------------------------------------------------------------------------- */
2816
2817 char *getErrorFilename(char *basename)
2818 {
2819   return getPath2(getUserGameDataDir(), basename);
2820 }
2821
2822 void openErrorFile()
2823 {
2824   InitUserDataDirectory();
2825
2826   if ((program.error_file = fopen(program.error_filename, MODE_WRITE)) == NULL)
2827     fprintf_newline(stderr, "ERROR: cannot open file '%s' for writing!",
2828                     program.error_filename);
2829 }
2830
2831 void closeErrorFile()
2832 {
2833   if (program.error_file != stderr)     /* do not close stream 'stderr' */
2834     fclose(program.error_file);
2835 }
2836
2837 void dumpErrorFile()
2838 {
2839   FILE *error_file = fopen(program.error_filename, MODE_READ);
2840
2841   if (error_file != NULL)
2842   {
2843     while (!feof(error_file))
2844       fputc(fgetc(error_file), stderr);
2845
2846     fclose(error_file);
2847   }
2848 }
2849
2850 void NotifyUserAboutErrorFile()
2851 {
2852 #if defined(PLATFORM_WIN32)
2853   char *title_text = getStringCat2(program.program_title, " Error Message");
2854   char *error_text = getStringCat2("The program was aborted due to an error; "
2855                                    "for details, see the following error file:"
2856                                    STRING_NEWLINE, program.error_filename);
2857
2858   MessageBox(NULL, error_text, title_text, MB_OK);
2859 #endif
2860 }
2861
2862
2863 /* ------------------------------------------------------------------------- */
2864 /* the following is only for debugging purpose and normally not used         */
2865 /* ------------------------------------------------------------------------- */
2866
2867 #if DEBUG
2868
2869 #define DEBUG_NUM_TIMESTAMPS            3
2870 #define DEBUG_TIME_IN_MICROSECONDS      0
2871
2872 #if DEBUG_TIME_IN_MICROSECONDS
2873 static double Counter_Microseconds()
2874 {
2875   static struct timeval base_time = { 0, 0 };
2876   struct timeval current_time;
2877   double counter;
2878
2879   gettimeofday(&current_time, NULL);
2880
2881   /* reset base time in case of wrap-around */
2882   if (current_time.tv_sec < base_time.tv_sec)
2883     base_time = current_time;
2884
2885   counter =
2886     ((double)(current_time.tv_sec  - base_time.tv_sec)) * 1000000 +
2887     ((double)(current_time.tv_usec - base_time.tv_usec));
2888
2889   return counter;               /* return microseconds since last init */
2890 }
2891 #endif
2892
2893 void debug_print_timestamp(int counter_nr, char *message)
2894 {
2895 #if DEBUG_TIME_IN_MICROSECONDS
2896   static double counter[DEBUG_NUM_TIMESTAMPS][2];
2897
2898   if (counter_nr >= DEBUG_NUM_TIMESTAMPS)
2899     Error(ERR_EXIT, "debugging: increase DEBUG_NUM_TIMESTAMPS in misc.c");
2900
2901   counter[counter_nr][0] = Counter_Microseconds();
2902
2903   if (message)
2904     printf("%s %.3f ms\n", message,
2905            (counter[counter_nr][0] - counter[counter_nr][1]) / 1000);
2906
2907   counter[counter_nr][1] = counter[counter_nr][0];
2908 #else
2909   static long counter[DEBUG_NUM_TIMESTAMPS][2];
2910
2911   if (counter_nr >= DEBUG_NUM_TIMESTAMPS)
2912     Error(ERR_EXIT, "debugging: increase DEBUG_NUM_TIMESTAMPS in misc.c");
2913
2914   counter[counter_nr][0] = Counter();
2915
2916   if (message)
2917     printf("%s %.3f s\n", message,
2918            (float)(counter[counter_nr][0] - counter[counter_nr][1]) / 1000);
2919
2920   counter[counter_nr][1] = counter[counter_nr][0];
2921 #endif
2922 }
2923
2924 void debug_print_parent_only(char *format, ...)
2925 {
2926   if (!IS_PARENT_PROCESS())
2927     return;
2928
2929   if (format)
2930   {
2931     va_list ap;
2932
2933     va_start(ap, format);
2934     vprintf(format, ap);
2935     va_end(ap);
2936
2937     printf("\n");
2938   }
2939 }
2940 #endif