util.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932
  1. /* -*- mode: c; tab-width: 4; c-basic-offset: 4; c-file-style: "linux" -*- */
  2. //
  3. // Copyright (c) 2009-2011, Wei Mingzhi <whistler_wmz@users.sf.net>.
  4. // Copyright (c) 2011-2017, SDLPAL development team.
  5. // All rights reserved.
  6. //
  7. // This file is part of SDLPAL.
  8. //
  9. // SDLPAL is free software: you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation, either version 3 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program. If not, see <http://www.gnu.org/licenses/>.
  21. //
  22. #include "util.h"
  23. #include "input.h"
  24. #include "global.h"
  25. #include "palcfg.h"
  26. #include <errno.h>
  27. #include "midi.h"
  28. #if SDL_VERSION_ATLEAST(2, 0, 0)
  29. #include "SDL_video.h"
  30. #include "SDL_messagebox.h"
  31. #endif
  32. static char internal_buffer[PAL_MAX_GLOBAL_BUFFERS + 1][PAL_GLOBAL_BUFFER_SIZE];
  33. #define INTERNAL_BUFFER_SIZE_ARGS internal_buffer[PAL_MAX_GLOBAL_BUFFERS], PAL_GLOBAL_BUFFER_SIZE
  34. void UTIL_MsgBox(char *string)
  35. {
  36. #if SDL_VERSION_ATLEAST(2, 0, 0)
  37. extern SDL_Window *gpWindow;
  38. char buffer[300];
  39. SDL_MessageBoxButtonData buttons[] = { { 0, 0, "OK" } };
  40. SDL_MessageBoxData mbd = { SDL_MESSAGEBOX_WARNING, gpWindow, "Alert",buffer, 1, buttons, NULL };
  41. int btnid;
  42. sprintf(buffer, "%s\n", string);
  43. SDL_ShowMessageBox(&mbd, &btnid);
  44. #endif
  45. }
  46. long
  47. flength(
  48. FILE *fp
  49. )
  50. {
  51. long old_pos = ftell(fp), length;
  52. if (old_pos == -1) return -1;
  53. if (fseek(fp, 0, SEEK_END) == -1) return -1;
  54. length = ftell(fp); fseek(fp, old_pos, SEEK_SET);
  55. return length;
  56. }
  57. void
  58. trim(
  59. char *str
  60. )
  61. /*++
  62. Purpose:
  63. Remove the leading and trailing spaces in a string.
  64. Parameters:
  65. str - the string to proceed.
  66. Return value:
  67. None.
  68. --*/
  69. {
  70. int pos = 0;
  71. char *dest = str;
  72. //
  73. // skip leading blanks
  74. //
  75. while (str[pos] <= ' ' && str[pos] > 0)
  76. pos++;
  77. while (str[pos])
  78. {
  79. *(dest++) = str[pos];
  80. pos++;
  81. }
  82. *(dest--) = '\0'; // store the null
  83. //
  84. // remove trailing blanks
  85. //
  86. while (dest >= str && *dest <= ' ' && *dest > 0)
  87. *(dest--) = '\0';
  88. }
  89. char *
  90. UTIL_va(
  91. char *buffer,
  92. int buflen,
  93. const char *format,
  94. ...
  95. )
  96. {
  97. if (buflen > 0 && buffer)
  98. {
  99. va_list argptr;
  100. va_start(argptr, format);
  101. vsnprintf(buffer, buflen, format, argptr);
  102. va_end(argptr);
  103. return buffer;
  104. }
  105. else
  106. {
  107. return NULL;
  108. }
  109. }
  110. /*
  111. * RNG code based on RACC by Pierre-Marie Baty.
  112. * http://racc.bots-united.com
  113. *
  114. * Copyright (c) 2004, Pierre-Marie Baty
  115. * All rights reserved.
  116. *
  117. * Redistribution and use in source and binary forms, with or
  118. * without modification, are permitted provided that the following
  119. * conditions are met:
  120. *
  121. * Redistributions of source code must retain the above copyright
  122. * notice, this list of conditions and the following disclaimer.
  123. *
  124. * Redistributions in binary form must reproduce the above copyright
  125. * notice, this list of conditions and the following disclaimer in
  126. * the documentation and/or other materials provided with the
  127. * distribution.
  128. *
  129. * Neither the name of the RACC nor the names of its contributors
  130. * may be used to endorse or promote products derived from this
  131. * software without specific prior written permission.
  132. *
  133. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  134. * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  135. * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  136. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  137. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  138. * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  139. * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  140. * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  141. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  142. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  143. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  144. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  145. * POSSIBILITY OF SUCH DAMAGE.
  146. */
  147. //
  148. // Our random number generator's seed.
  149. //
  150. static int glSeed = 0;
  151. static void
  152. lsrand(
  153. unsigned int iInitialSeed
  154. )
  155. /*++
  156. Purpose:
  157. This function initializes the random seed based on the initial seed value passed in the
  158. iInitialSeed parameter.
  159. Parameters:
  160. [IN] iInitialSeed - The initial random seed.
  161. Return value:
  162. None.
  163. --*/
  164. {
  165. //
  166. // fill in the initial seed of the random number generator
  167. //
  168. glSeed = 1664525L * iInitialSeed + 1013904223L;
  169. }
  170. static int
  171. lrand(
  172. void
  173. )
  174. /*++
  175. Purpose:
  176. This function is the equivalent of the rand() standard C library function, except that
  177. whereas rand() works only with short integers (i.e. not above 32767), this function is
  178. able to generate 32-bit random numbers.
  179. Parameters:
  180. None.
  181. Return value:
  182. The generated random number.
  183. --*/
  184. {
  185. if (glSeed == 0) // if the random seed isn't initialized...
  186. lsrand((unsigned int)time(NULL)); // initialize it first
  187. glSeed = 1664525L * glSeed + 1013904223L; // do some twisted math (infinite suite)
  188. return ((glSeed >> 1) + 1073741824L); // and return the result.
  189. }
  190. int
  191. RandomLong(
  192. int from,
  193. int to
  194. )
  195. /*++
  196. Purpose:
  197. This function returns a random integer number between (and including) the starting and
  198. ending values passed by parameters from and to.
  199. Parameters:
  200. from - the starting value.
  201. to - the ending value.
  202. Return value:
  203. The generated random number.
  204. --*/
  205. {
  206. if (to <= from)
  207. return from;
  208. return from + lrand() / (INT_MAX / (to - from + 1));
  209. }
  210. float
  211. RandomFloat(
  212. float from,
  213. float to
  214. )
  215. /*++
  216. Purpose:
  217. This function returns a random floating-point number between (and including) the starting
  218. and ending values passed by parameters from and to.
  219. Parameters:
  220. from - the starting value.
  221. to - the ending value.
  222. Return value:
  223. The generated random number.
  224. --*/
  225. {
  226. if (to <= from)
  227. return from;
  228. return from + (float)lrand() / (INT_MAX / (to - from));
  229. }
  230. void
  231. UTIL_Delay(
  232. unsigned int ms
  233. )
  234. {
  235. unsigned int t = SDL_GetTicks() + ms;
  236. PAL_ProcessEvent();
  237. while (!SDL_TICKS_PASSED(SDL_GetTicks(), t))
  238. {
  239. SDL_Delay(1);
  240. PAL_ProcessEvent();
  241. }
  242. }
  243. void
  244. TerminateOnError(
  245. const char *fmt,
  246. ...
  247. )
  248. // This function terminates the game because of an error and
  249. // prints the message string pointed to by fmt both in the
  250. // console and in a messagebox.
  251. {
  252. va_list argptr;
  253. char string[256];
  254. extern VOID PAL_Shutdown(int);
  255. // concatenate all the arguments in one string
  256. va_start(argptr, fmt);
  257. vsnprintf(string, sizeof(string), fmt, argptr);
  258. va_end(argptr);
  259. fprintf(stderr, "\nFATAL ERROR: %s\n", string);
  260. #if SDL_VERSION_ATLEAST(2, 0, 0)
  261. {
  262. extern SDL_Window *gpWindow;
  263. char buffer[300];
  264. SDL_MessageBoxButtonData buttons[2] = { { 0, 0, "Yes" },{ 0, 1, "No" } };
  265. SDL_MessageBoxData mbd = { SDL_MESSAGEBOX_ERROR, gpWindow, "FATAL ERROR", buffer, 2, buttons, NULL };
  266. int btnid;
  267. sprintf(buffer, "%sLaunch setting dialog on next start?\n", string);
  268. if (SDL_ShowMessageBox(&mbd, &btnid) == 0 && btnid == 0)
  269. {
  270. gConfig.fLaunchSetting = TRUE;
  271. PAL_SaveConfig();
  272. }
  273. PAL_Shutdown(255);
  274. }
  275. #else
  276. PAL_FATAL_OUTPUT(string);
  277. #endif
  278. #ifdef _DEBUG
  279. assert(!"TerminateOnError()"); // allows jumping to debugger
  280. #endif
  281. PAL_Shutdown(255);
  282. }
  283. void *
  284. UTIL_malloc(
  285. size_t buffer_size
  286. )
  287. {
  288. // handy wrapper for operations we always forget, like checking malloc's returned pointer.
  289. void *buffer;
  290. // first off, check if buffer size is valid
  291. if (buffer_size == 0)
  292. TerminateOnError("UTIL_malloc() called with invalid buffer size: %d\n", buffer_size);
  293. buffer = malloc(buffer_size); // allocate real memory space
  294. // last check, check if malloc call succeeded
  295. if (buffer == NULL)
  296. TerminateOnError("UTIL_malloc() failure for %d bytes (out of memory?)\n", buffer_size);
  297. return buffer; // nothing went wrong, so return buffer pointer
  298. }
  299. void *
  300. UTIL_calloc(
  301. size_t n,
  302. size_t size
  303. )
  304. {
  305. // handy wrapper for operations we always forget, like checking calloc's returned pointer.
  306. void *buffer;
  307. // first off, check if buffer size is valid
  308. if (n == 0 || size == 0)
  309. TerminateOnError ("UTIL_calloc() called with invalid parameters\n");
  310. buffer = calloc(n, size); // allocate real memory space
  311. // last check, check if malloc call succeeded
  312. if (buffer == NULL)
  313. TerminateOnError("UTIL_calloc() failure for %d bytes (out of memory?)\n", size * n);
  314. return buffer; // nothing went wrong, so return buffer pointer
  315. }
  316. FILE *
  317. UTIL_OpenRequiredFile(
  318. LPCSTR lpszFileName
  319. )
  320. /*++
  321. Purpose:
  322. Open a required file. If fails, quit the program.
  323. Parameters:
  324. [IN] lpszFileName - file name to open.
  325. Return value:
  326. Pointer to the file.
  327. --*/
  328. {
  329. return UTIL_OpenRequiredFileForMode(lpszFileName, "rb");
  330. }
  331. FILE *
  332. UTIL_OpenRequiredFileForMode(
  333. LPCSTR lpszFileName,
  334. LPCSTR szMode
  335. )
  336. /*++
  337. Purpose:
  338. Open a required file. If fails, quit the program.
  339. Parameters:
  340. [IN] lpszFileName - file name to open.
  341. [IN] szMode - file open mode.
  342. Return value:
  343. Pointer to the file.
  344. --*/
  345. {
  346. FILE *fp = UTIL_OpenFileForMode(lpszFileName, szMode);
  347. if (fp == NULL)
  348. {
  349. TerminateOnError("File open error(%d): %s!\n", errno, lpszFileName);
  350. }
  351. return fp;
  352. }
  353. FILE *
  354. UTIL_OpenFile(
  355. LPCSTR lpszFileName
  356. )
  357. /*++
  358. Purpose:
  359. Open a file. If fails, return NULL.
  360. Parameters:
  361. [IN] lpszFileName - file name to open.
  362. Return value:
  363. Pointer to the file.
  364. --*/
  365. {
  366. return UTIL_OpenFileForMode(lpszFileName, "rb");
  367. }
  368. FILE *
  369. UTIL_OpenFileForMode(
  370. LPCSTR lpszFileName,
  371. LPCSTR szMode
  372. )
  373. /*++
  374. Purpose:
  375. Open a file. If fails, return NULL.
  376. Parameters:
  377. [IN] lpszFileName - file name to open.
  378. [IN] szMode - file open mode.
  379. Return value:
  380. Pointer to the file.
  381. --*/
  382. {
  383. //
  384. // If lpszFileName is an absolute path, use its last element as filename
  385. //
  386. if (UTIL_IsAbsolutePath(lpszFileName))
  387. {
  388. char *temp = strdup(lpszFileName), *filename = temp;
  389. FILE *fp = NULL;
  390. for (char *next = strpbrk(filename, PAL_PATH_SEPARATORS); next; next = strpbrk(filename = next + 1, PAL_PATH_SEPARATORS));
  391. if (*filename)
  392. {
  393. filename[-1] = '\0';
  394. fp = UTIL_OpenFileAtPathForMode(*temp ? temp : "/", filename, szMode);
  395. }
  396. free(temp);
  397. return fp;
  398. }
  399. return UTIL_OpenFileAtPathForMode(gConfig.pszGamePath, lpszFileName, szMode);
  400. }
  401. FILE *
  402. UTIL_OpenFileAtPath(
  403. LPCSTR lpszPath,
  404. LPCSTR lpszFileName
  405. )
  406. {
  407. return UTIL_OpenFileAtPathForMode(lpszPath, lpszFileName, "rb");
  408. }
  409. FILE *
  410. UTIL_OpenFileAtPathForMode(
  411. LPCSTR lpszPath,
  412. LPCSTR lpszFileName,
  413. LPCSTR szMode
  414. )
  415. {
  416. if (!lpszPath || !lpszFileName || !szMode) return NULL;
  417. //
  418. // Construct full path according to lpszPath and lpszFileName
  419. //
  420. const char *path = UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, lpszPath, lpszFileName);
  421. //
  422. // If no matching path, check the open mode
  423. //
  424. if (path)
  425. {
  426. return fopen(path, szMode);
  427. }
  428. else if (szMode[0] != 'r')
  429. {
  430. return fopen(UTIL_CombinePath(INTERNAL_BUFFER_SIZE_ARGS, 2, lpszPath, lpszFileName), szMode);
  431. }
  432. else
  433. {
  434. return NULL;
  435. }
  436. }
  437. VOID
  438. UTIL_CloseFile(
  439. FILE *fp
  440. )
  441. /*++
  442. Purpose:
  443. Close a file.
  444. Parameters:
  445. [IN] fp - file handle to be closed.
  446. Return value:
  447. None.
  448. --*/
  449. {
  450. if (fp != NULL)
  451. {
  452. fclose(fp);
  453. }
  454. }
  455. const char *
  456. UTIL_GetFullPathName(
  457. char *buffer,
  458. size_t buflen,
  459. const char *basepath,
  460. const char *subpath
  461. )
  462. {
  463. if (!buffer || !basepath || !subpath || buflen == 0) return NULL;
  464. int baselen = strlen(basepath), sublen = strlen(subpath);
  465. if (sublen == 0) return NULL;
  466. char *_base = strdup(basepath), *_sub = strdup(subpath);
  467. const char *result = NULL;
  468. if (access(UTIL_CombinePath(INTERNAL_BUFFER_SIZE_ARGS, 2, _base, _sub), 0) == 0)
  469. {
  470. result = internal_buffer[PAL_MAX_GLOBAL_BUFFERS];
  471. }
  472. #if !defined(PAL_FILESYSTEM_IGNORE_CASE) || !PAL_FILESYSTEM_IGNORE_CASE
  473. if (result == NULL)
  474. {
  475. size_t pos = strspn(_sub, PAL_PATH_SEPARATORS);
  476. if (pos < sublen)
  477. {
  478. char *start = _sub + pos;
  479. char *end = strpbrk(start, PAL_PATH_SEPARATORS);
  480. if (end) *end = '\0';
  481. //
  482. // try to find the matching file in the directory.
  483. //
  484. struct dirent **list;
  485. int n = scandir(_base, &list, 0, alphasort);
  486. while (n-- > 0)
  487. {
  488. if (!result && strcasecmp(list[n]->d_name, start) == 0)
  489. {
  490. result = UTIL_CombinePath(INTERNAL_BUFFER_SIZE_ARGS, 2, _base, list[n]->d_name);
  491. if (end)
  492. result = UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, result, end + 1);
  493. else if (access(result, 0) != 0)
  494. result = NULL;
  495. }
  496. free(list[n]);
  497. }
  498. free(list);
  499. }
  500. }
  501. #endif
  502. if (result != NULL)
  503. {
  504. result = (char *)memmove(buffer, result, min(buflen, strlen(result)));
  505. }
  506. free(_base);
  507. free(_sub);
  508. return result;
  509. }
  510. const char *
  511. UTIL_CombinePath(
  512. char *buffer,
  513. size_t buflen,
  514. int numentry,
  515. ...
  516. )
  517. {
  518. if (buffer && buflen > 0 && numentry > 0)
  519. {
  520. const char *retval = buffer;
  521. va_list argptr;
  522. va_start(argptr, numentry);
  523. for (int i = 0; i < numentry && buflen > 1; i++)
  524. {
  525. const char *path = va_arg(argptr, const char *);
  526. int path_len = path ? strlen(path) : 0;
  527. int append_delim = (i < numentry - 1 && path_len > 0 && !PAL_IS_PATH_SEPARATOR(path[path_len - 1]));
  528. for (int is_sep = 0, j = 0; j < path_len && buflen > (size_t)append_delim + 1; j++)
  529. {
  530. //
  531. // Skip continuous path separators
  532. //
  533. if (PAL_IS_PATH_SEPARATOR(path[j]))
  534. {
  535. if (is_sep)
  536. continue;
  537. else
  538. is_sep = 1;
  539. }
  540. else
  541. {
  542. is_sep = 0;
  543. }
  544. *buffer++ = path[j];
  545. buflen--;
  546. }
  547. //
  548. // Make sure a path delimeter is append to the destination if this is not the last entry
  549. //
  550. if (append_delim)
  551. {
  552. *buffer++ = PAL_PATH_SEPARATORS[0];
  553. buflen--;
  554. }
  555. }
  556. va_end(argptr);
  557. *buffer = '\0';
  558. return retval;
  559. }
  560. else
  561. {
  562. return NULL;
  563. }
  564. }
  565. char *
  566. UTIL_GlobalBuffer(
  567. int index
  568. )
  569. {
  570. return (index >= 0 && index < PAL_MAX_GLOBAL_BUFFERS) ? internal_buffer[index] : NULL;
  571. }
  572. PALFILE
  573. UTIL_CheckResourceFiles(
  574. const char *path,
  575. const char *msgfile
  576. )
  577. {
  578. const char *common_files[] = {
  579. "abc.mkf", "ball.mkf", "data.mkf", "f.mkf",
  580. "fbp.mkf", "fire.mkf", "gop.mkf", "map.mkf",
  581. "mgo.mkf", "pat.mkf", "rgm.mkf", "rng.mkf",
  582. "sss.mkf"
  583. };
  584. const char *msg_files[][2] = {
  585. { msgfile, "m.msg" },
  586. { msgfile, "word.dat" }
  587. };
  588. const char *sound_files[2] = { "voc.mkf", "sounds.mkf" };
  589. const char *music_files[2] = { "midi.mkf", "mus.mkf" };
  590. int msgidx = !(msgfile && *msgfile);
  591. PALFILE retval = (PALFILE)0;
  592. for (int i = 0; i < sizeof(common_files) / sizeof(common_files[0]); i++)
  593. {
  594. if (!UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, path, common_files[i]))
  595. {
  596. retval |= (PALFILE)(1 << i);
  597. }
  598. }
  599. for (int i = 0; i < sizeof(msg_files[0]) / sizeof(msg_files[0][0]); i++)
  600. {
  601. if (!UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, path, msg_files[i][msgidx]))
  602. {
  603. retval |= (PALFILE)(1 << ((i + 1) * msgidx + 13));
  604. }
  605. }
  606. for (int i = 0; i < sizeof(sound_files) / sizeof(sound_files[0]); i++)
  607. {
  608. if (!UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, path, sound_files[i]))
  609. {
  610. retval |= (PALFILE)(1 << (i + 16));
  611. }
  612. }
  613. for (int i = 0; i < sizeof(music_files) / sizeof(music_files[0]); i++)
  614. {
  615. if (!UTIL_GetFullPathName(INTERNAL_BUFFER_SIZE_ARGS, path, music_files[i]))
  616. {
  617. retval |= (PALFILE)(1 << (i + 18));
  618. }
  619. }
  620. return retval;
  621. }
  622. #if !defined(PAL_HAS_PLATFORM_SPECIFIC_UTILS)
  623. BOOL
  624. UTIL_GetScreenSize(
  625. DWORD *pdwScreenWidth,
  626. DWORD *pdwScreenHeight
  627. )
  628. {
  629. return FALSE;
  630. }
  631. BOOL
  632. UTIL_IsAbsolutePath(
  633. LPCSTR lpszFileName
  634. )
  635. {
  636. return FALSE;
  637. }
  638. INT
  639. UTIL_Platform_Init(
  640. int argc,
  641. char* argv[]
  642. )
  643. {
  644. gConfig.fLaunchSetting = FALSE;
  645. return 0;
  646. }
  647. VOID
  648. UTIL_Platform_Quit(
  649. VOID
  650. )
  651. {
  652. }
  653. #endif
  654. /*
  655. * Logging utilities
  656. */
  657. #ifndef PAL_LOG_BUFFER_SIZE
  658. # define PAL_LOG_BUFFER_SIZE 4096
  659. #endif
  660. #define PAL_LOG_BUFFER_EXTRA_SIZE 32
  661. static LOGCALLBACK _log_callbacks[PAL_LOG_MAX_OUTPUTS];
  662. static LOGLEVEL _log_callback_levels[PAL_LOG_MAX_OUTPUTS];
  663. static char _log_buffer[PAL_LOG_BUFFER_SIZE + PAL_LOG_BUFFER_EXTRA_SIZE];
  664. static const char * const _loglevel_str[] = {
  665. "[VERBOSE]",
  666. " [DEBUG]",
  667. " [INFO]",
  668. "[WARNING]",
  669. " [ERROR]",
  670. " [FATAL]",
  671. };
  672. int
  673. UTIL_LogAddOutputCallback(
  674. LOGCALLBACK callback,
  675. LOGLEVEL loglevel
  676. )
  677. {
  678. if (!callback) return -1;
  679. // De-duplication
  680. for (int i = 0; i < PAL_LOG_MAX_OUTPUTS; i++)
  681. {
  682. if (!_log_callbacks[i])
  683. {
  684. _log_callbacks[i] = callback;
  685. }
  686. if (_log_callbacks[i] == callback)
  687. {
  688. _log_callback_levels[i] = loglevel;
  689. return i;
  690. }
  691. }
  692. return -1;
  693. }
  694. void
  695. UTIL_LogRemoveOutputCallback(
  696. int id
  697. )
  698. {
  699. if (id < 0 || id >= PAL_LOG_MAX_OUTPUTS) return;
  700. while (id < PAL_LOG_MAX_OUTPUTS - 1)
  701. {
  702. _log_callbacks[id] = _log_callbacks[id + 1];
  703. _log_callback_levels[id] = _log_callback_levels[id + 1];
  704. id++;
  705. }
  706. _log_callbacks[id] = NULL;
  707. _log_callback_levels[id] = LOGLEVEL_MIN;
  708. }
  709. void
  710. UTIL_LogOutput(
  711. LOGLEVEL level,
  712. const char *fmt,
  713. ...
  714. )
  715. {
  716. va_list va;
  717. time_t tv = time(NULL);
  718. struct tm *tmval = localtime(&tv);
  719. int id, n;
  720. if (level < gConfig.iLogLevel || !_log_callbacks[0]) return;
  721. if (level > LOGLEVEL_MAX) level = LOGLEVEL_MAX;
  722. snprintf(_log_buffer, PAL_LOG_BUFFER_EXTRA_SIZE,
  723. "%04d-%02d-%02d %02d:%02d:%02d %s: ",
  724. tmval->tm_year + 1900, tmval->tm_mon, tmval->tm_mday,
  725. tmval->tm_hour, tmval->tm_min, tmval->tm_sec,
  726. _loglevel_str[level]);
  727. va_start(va, fmt);
  728. n = vsnprintf(_log_buffer + PAL_LOG_BUFFER_EXTRA_SIZE - 1, PAL_LOG_BUFFER_SIZE, fmt, va);
  729. va_end(va);
  730. n = (n == -1) ? PAL_LOG_BUFFER_EXTRA_SIZE + PAL_LOG_BUFFER_SIZE - 1 : n + PAL_LOG_BUFFER_EXTRA_SIZE;
  731. _log_buffer[n--] = '\0';
  732. if (_log_buffer[n] != '\n') _log_buffer[n] = '\n';
  733. for(id = 0; id < PAL_LOG_MAX_OUTPUTS && _log_callbacks[id]; id++)
  734. {
  735. if (level >= _log_callback_levels[id])
  736. {
  737. _log_callbacks[id](level, _log_buffer, _log_buffer + PAL_LOG_BUFFER_EXTRA_SIZE - 1);
  738. }
  739. }
  740. }
  741. void
  742. UTIL_LogSetLevel(
  743. LOGLEVEL minlevel
  744. )
  745. {
  746. if (minlevel < LOGLEVEL_MIN)
  747. gConfig.iLogLevel = LOGLEVEL_MIN;
  748. else if (minlevel > LOGLEVEL_MAX)
  749. gConfig.iLogLevel = LOGLEVEL_MAX;
  750. else
  751. gConfig.iLogLevel = minlevel;
  752. }
  753. void
  754. UTIL_LogToFile(
  755. LOGLEVEL _,
  756. const char *string,
  757. const char *__
  758. )
  759. {
  760. FILE *fp = fopen(gConfig.pszLogFile, "a");
  761. if (fp)
  762. {
  763. fputs(string, fp);
  764. fclose(fp);
  765. }
  766. }