SDL_string.c 48 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855
  1. /*
  2. Simple DirectMedia Layer
  3. Copyright (C) 1997-2019 Sam Lantinga <[email protected]>
  4. This software is provided 'as-is', without any express or implied
  5. warranty. In no event will the authors be held liable for any damages
  6. arising from the use of this software.
  7. Permission is granted to anyone to use this software for any purpose,
  8. including commercial applications, and to alter it and redistribute it
  9. freely, subject to the following restrictions:
  10. 1. The origin of this software must not be misrepresented; you must not
  11. claim that you wrote the original software. If you use this software
  12. in a product, an acknowledgment in the product documentation would be
  13. appreciated but is not required.
  14. 2. Altered source versions must be plainly marked as such, and must not be
  15. misrepresented as being the original software.
  16. 3. This notice may not be removed or altered from any source distribution.
  17. */
  18. #if defined(__clang_analyzer__)
  19. #define SDL_DISABLE_ANALYZE_MACROS 1
  20. #endif
  21. #include "../SDL_internal.h"
  22. /* This file contains portable string manipulation functions for SDL */
  23. #include "SDL_stdinc.h"
  24. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOLL) || !defined(HAVE_STRTOULL) || !defined(HAVE_STRTOD)
  25. #define SDL_isupperhex(X) (((X) >= 'A') && ((X) <= 'F'))
  26. #define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f'))
  27. #endif
  28. #define UTF8_IsLeadByte(c) ((c) >= 0xC0 && (c) <= 0xF4)
  29. #define UTF8_IsTrailingByte(c) ((c) >= 0x80 && (c) <= 0xBF)
  30. static int UTF8_TrailingBytes(unsigned char c)
  31. {
  32. if (c >= 0xC0 && c <= 0xDF)
  33. return 1;
  34. else if (c >= 0xE0 && c <= 0xEF)
  35. return 2;
  36. else if (c >= 0xF0 && c <= 0xF4)
  37. return 3;
  38. else
  39. return 0;
  40. }
  41. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL)
  42. static size_t
  43. SDL_ScanLong(const char *text, int radix, long *valuep)
  44. {
  45. const char *textstart = text;
  46. long value = 0;
  47. SDL_bool negative = SDL_FALSE;
  48. if (*text == '-') {
  49. negative = SDL_TRUE;
  50. ++text;
  51. }
  52. if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
  53. text += 2;
  54. }
  55. for (;;) {
  56. int v;
  57. if (SDL_isdigit((unsigned char) *text)) {
  58. v = *text - '0';
  59. } else if (radix == 16 && SDL_isupperhex(*text)) {
  60. v = 10 + (*text - 'A');
  61. } else if (radix == 16 && SDL_islowerhex(*text)) {
  62. v = 10 + (*text - 'a');
  63. } else {
  64. break;
  65. }
  66. value *= radix;
  67. value += v;
  68. ++text;
  69. }
  70. if (valuep && text > textstart) {
  71. if (negative && value) {
  72. *valuep = -value;
  73. } else {
  74. *valuep = value;
  75. }
  76. }
  77. return (text - textstart);
  78. }
  79. #endif
  80. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD)
  81. static size_t
  82. SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)
  83. {
  84. const char *textstart = text;
  85. unsigned long value = 0;
  86. if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
  87. text += 2;
  88. }
  89. for (;;) {
  90. int v;
  91. if (SDL_isdigit((unsigned char) *text)) {
  92. v = *text - '0';
  93. } else if (radix == 16 && SDL_isupperhex(*text)) {
  94. v = 10 + (*text - 'A');
  95. } else if (radix == 16 && SDL_islowerhex(*text)) {
  96. v = 10 + (*text - 'a');
  97. } else {
  98. break;
  99. }
  100. value *= radix;
  101. value += v;
  102. ++text;
  103. }
  104. if (valuep && text > textstart) {
  105. *valuep = value;
  106. }
  107. return (text - textstart);
  108. }
  109. #endif
  110. #ifndef HAVE_VSSCANF
  111. static size_t
  112. SDL_ScanUintPtrT(const char *text, int radix, uintptr_t * valuep)
  113. {
  114. const char *textstart = text;
  115. uintptr_t value = 0;
  116. if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
  117. text += 2;
  118. }
  119. for (;;) {
  120. int v;
  121. if (SDL_isdigit((unsigned char) *text)) {
  122. v = *text - '0';
  123. } else if (radix == 16 && SDL_isupperhex(*text)) {
  124. v = 10 + (*text - 'A');
  125. } else if (radix == 16 && SDL_islowerhex(*text)) {
  126. v = 10 + (*text - 'a');
  127. } else {
  128. break;
  129. }
  130. value *= radix;
  131. value += v;
  132. ++text;
  133. }
  134. if (valuep && text > textstart) {
  135. *valuep = value;
  136. }
  137. return (text - textstart);
  138. }
  139. #endif
  140. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOLL)
  141. static size_t
  142. SDL_ScanLongLong(const char *text, int radix, Sint64 * valuep)
  143. {
  144. const char *textstart = text;
  145. Sint64 value = 0;
  146. SDL_bool negative = SDL_FALSE;
  147. if (*text == '-') {
  148. negative = SDL_TRUE;
  149. ++text;
  150. }
  151. if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
  152. text += 2;
  153. }
  154. for (;;) {
  155. int v;
  156. if (SDL_isdigit((unsigned char) *text)) {
  157. v = *text - '0';
  158. } else if (radix == 16 && SDL_isupperhex(*text)) {
  159. v = 10 + (*text - 'A');
  160. } else if (radix == 16 && SDL_islowerhex(*text)) {
  161. v = 10 + (*text - 'a');
  162. } else {
  163. break;
  164. }
  165. value *= radix;
  166. value += v;
  167. ++text;
  168. }
  169. if (valuep && text > textstart) {
  170. if (negative && value) {
  171. *valuep = -value;
  172. } else {
  173. *valuep = value;
  174. }
  175. }
  176. return (text - textstart);
  177. }
  178. #endif
  179. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOULL)
  180. static size_t
  181. SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 * valuep)
  182. {
  183. const char *textstart = text;
  184. Uint64 value = 0;
  185. if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
  186. text += 2;
  187. }
  188. for (;;) {
  189. int v;
  190. if (SDL_isdigit((unsigned char) *text)) {
  191. v = *text - '0';
  192. } else if (radix == 16 && SDL_isupperhex(*text)) {
  193. v = 10 + (*text - 'A');
  194. } else if (radix == 16 && SDL_islowerhex(*text)) {
  195. v = 10 + (*text - 'a');
  196. } else {
  197. break;
  198. }
  199. value *= radix;
  200. value += v;
  201. ++text;
  202. }
  203. if (valuep && text > textstart) {
  204. *valuep = value;
  205. }
  206. return (text - textstart);
  207. }
  208. #endif
  209. #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOD)
  210. static size_t
  211. SDL_ScanFloat(const char *text, double *valuep)
  212. {
  213. const char *textstart = text;
  214. unsigned long lvalue = 0;
  215. double value = 0.0;
  216. SDL_bool negative = SDL_FALSE;
  217. if (*text == '-') {
  218. negative = SDL_TRUE;
  219. ++text;
  220. }
  221. text += SDL_ScanUnsignedLong(text, 10, &lvalue);
  222. value += lvalue;
  223. if (*text == '.') {
  224. int mult = 10;
  225. ++text;
  226. while (SDL_isdigit((unsigned char) *text)) {
  227. lvalue = *text - '0';
  228. value += (double) lvalue / mult;
  229. mult *= 10;
  230. ++text;
  231. }
  232. }
  233. if (valuep && text > textstart) {
  234. if (negative && value) {
  235. *valuep = -value;
  236. } else {
  237. *valuep = value;
  238. }
  239. }
  240. return (text - textstart);
  241. }
  242. #endif
  243. void *
  244. SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len)
  245. {
  246. #if defined(HAVE_MEMSET)
  247. return memset(dst, c, len);
  248. #else
  249. size_t left;
  250. Uint32 *dstp4;
  251. Uint8 *dstp1 = (Uint8 *) dst;
  252. Uint8 value1;
  253. Uint32 value4;
  254. /* The value used in memset() is a byte, passed as an int */
  255. c &= 0xff;
  256. /* The destination pointer needs to be aligned on a 4-byte boundary to
  257. * execute a 32-bit set. Set first bytes manually if needed until it is
  258. * aligned. */
  259. value1 = (Uint8)c;
  260. while ((intptr_t)dstp1 & 0x3) {
  261. if (len--) {
  262. *dstp1++ = value1;
  263. } else {
  264. return dst;
  265. }
  266. }
  267. value4 = (c | (c << 8) | (c << 16) | (c << 24));
  268. dstp4 = (Uint32 *) dstp1;
  269. left = (len % 4);
  270. len /= 4;
  271. while (len--) {
  272. *dstp4++ = value4;
  273. }
  274. dstp1 = (Uint8 *) dstp4;
  275. switch (left) {
  276. case 3:
  277. *dstp1++ = value1;
  278. case 2:
  279. *dstp1++ = value1;
  280. case 1:
  281. *dstp1++ = value1;
  282. }
  283. return dst;
  284. #endif /* HAVE_MEMSET */
  285. }
  286. void *
  287. SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len)
  288. {
  289. #ifdef __GNUC__
  290. /* Presumably this is well tuned for speed.
  291. On my machine this is twice as fast as the C code below.
  292. */
  293. return __builtin_memcpy(dst, src, len);
  294. #elif defined(HAVE_MEMCPY)
  295. return memcpy(dst, src, len);
  296. #elif defined(HAVE_BCOPY)
  297. bcopy(src, dst, len);
  298. return dst;
  299. #else
  300. /* GCC 4.9.0 with -O3 will generate movaps instructions with the loop
  301. using Uint32* pointers, so we need to make sure the pointers are
  302. aligned before we loop using them.
  303. */
  304. if (((intptr_t)src & 0x3) || ((intptr_t)dst & 0x3)) {
  305. /* Do an unaligned byte copy */
  306. Uint8 *srcp1 = (Uint8 *)src;
  307. Uint8 *dstp1 = (Uint8 *)dst;
  308. while (len--) {
  309. *dstp1++ = *srcp1++;
  310. }
  311. } else {
  312. size_t left = (len % 4);
  313. Uint32 *srcp4, *dstp4;
  314. Uint8 *srcp1, *dstp1;
  315. srcp4 = (Uint32 *) src;
  316. dstp4 = (Uint32 *) dst;
  317. len /= 4;
  318. while (len--) {
  319. *dstp4++ = *srcp4++;
  320. }
  321. srcp1 = (Uint8 *) srcp4;
  322. dstp1 = (Uint8 *) dstp4;
  323. switch (left) {
  324. case 3:
  325. *dstp1++ = *srcp1++;
  326. case 2:
  327. *dstp1++ = *srcp1++;
  328. case 1:
  329. *dstp1++ = *srcp1++;
  330. }
  331. }
  332. return dst;
  333. #endif /* __GNUC__ */
  334. }
  335. void *
  336. SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len)
  337. {
  338. #if defined(HAVE_MEMMOVE)
  339. return memmove(dst, src, len);
  340. #else
  341. char *srcp = (char *) src;
  342. char *dstp = (char *) dst;
  343. if (src < dst) {
  344. srcp += len - 1;
  345. dstp += len - 1;
  346. while (len--) {
  347. *dstp-- = *srcp--;
  348. }
  349. } else {
  350. while (len--) {
  351. *dstp++ = *srcp++;
  352. }
  353. }
  354. return dst;
  355. #endif /* HAVE_MEMMOVE */
  356. }
  357. int
  358. SDL_memcmp(const void *s1, const void *s2, size_t len)
  359. {
  360. #if defined(HAVE_MEMCMP)
  361. return memcmp(s1, s2, len);
  362. #else
  363. char *s1p = (char *) s1;
  364. char *s2p = (char *) s2;
  365. while (len--) {
  366. if (*s1p != *s2p) {
  367. return (*s1p - *s2p);
  368. }
  369. ++s1p;
  370. ++s2p;
  371. }
  372. return 0;
  373. #endif /* HAVE_MEMCMP */
  374. }
  375. size_t
  376. SDL_strlen(const char *string)
  377. {
  378. #if defined(HAVE_STRLEN)
  379. return strlen(string);
  380. #else
  381. size_t len = 0;
  382. while (*string++) {
  383. ++len;
  384. }
  385. return len;
  386. #endif /* HAVE_STRLEN */
  387. }
  388. size_t
  389. SDL_wcslen(const wchar_t * string)
  390. {
  391. #if defined(HAVE_WCSLEN)
  392. return wcslen(string);
  393. #else
  394. size_t len = 0;
  395. while (*string++) {
  396. ++len;
  397. }
  398. return len;
  399. #endif /* HAVE_WCSLEN */
  400. }
  401. size_t
  402. SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen)
  403. {
  404. #if defined(HAVE_WCSLCPY)
  405. return wcslcpy(dst, src, maxlen);
  406. #else
  407. size_t srclen = SDL_wcslen(src);
  408. if (maxlen > 0) {
  409. size_t len = SDL_min(srclen, maxlen - 1);
  410. SDL_memcpy(dst, src, len * sizeof(wchar_t));
  411. dst[len] = '\0';
  412. }
  413. return srclen;
  414. #endif /* HAVE_WCSLCPY */
  415. }
  416. size_t
  417. SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen)
  418. {
  419. #if defined(HAVE_WCSLCAT)
  420. return wcslcat(dst, src, maxlen);
  421. #else
  422. size_t dstlen = SDL_wcslen(dst);
  423. size_t srclen = SDL_wcslen(src);
  424. if (dstlen < maxlen) {
  425. SDL_wcslcpy(dst + dstlen, src, maxlen - dstlen);
  426. }
  427. return dstlen + srclen;
  428. #endif /* HAVE_WCSLCAT */
  429. }
  430. wchar_t *
  431. SDL_wcsdup(const wchar_t *string)
  432. {
  433. size_t len = ((SDL_wcslen(string) + 1) * sizeof(wchar_t));
  434. wchar_t *newstr = (wchar_t *)SDL_malloc(len);
  435. if (newstr) {
  436. SDL_memcpy(newstr, string, len);
  437. }
  438. return newstr;
  439. }
  440. wchar_t *
  441. SDL_wcsstr(const wchar_t *haystack, const wchar_t *needle)
  442. {
  443. #if defined(HAVE_WCSSTR)
  444. return SDL_const_cast(wchar_t*,wcsstr(haystack, needle));
  445. #else
  446. size_t length = SDL_wcslen(needle);
  447. while (*haystack) {
  448. if (SDL_wcsncmp(haystack, needle, length) == 0) {
  449. return (wchar_t *)haystack;
  450. }
  451. ++haystack;
  452. }
  453. return NULL;
  454. #endif /* HAVE_WCSSTR */
  455. }
  456. int
  457. SDL_wcscmp(const wchar_t *str1, const wchar_t *str2)
  458. {
  459. #if defined(HAVE_WCSCMP)
  460. return wcscmp(str1, str2);
  461. #else
  462. while (*str1 && *str2) {
  463. if (*str1 != *str2)
  464. break;
  465. ++str1;
  466. ++str2;
  467. }
  468. return (int)(*str1 - *str2);
  469. #endif /* HAVE_WCSCMP */
  470. }
  471. int
  472. SDL_wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen)
  473. {
  474. #if defined(HAVE_WCSNCMP)
  475. return wcsncmp(str1, str2, maxlen);
  476. #else
  477. while (*str1 && *str2) {
  478. if (*str1 != *str2)
  479. break;
  480. ++str1;
  481. ++str2;
  482. }
  483. return (int)(*str1 - *str2);
  484. #endif /* HAVE_WCSNCMP */
  485. }
  486. size_t
  487. SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen)
  488. {
  489. #if defined(HAVE_STRLCPY)
  490. return strlcpy(dst, src, maxlen);
  491. #else
  492. size_t srclen = SDL_strlen(src);
  493. if (maxlen > 0) {
  494. size_t len = SDL_min(srclen, maxlen - 1);
  495. SDL_memcpy(dst, src, len);
  496. dst[len] = '\0';
  497. }
  498. return srclen;
  499. #endif /* HAVE_STRLCPY */
  500. }
  501. size_t
  502. SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes)
  503. {
  504. size_t src_bytes = SDL_strlen(src);
  505. size_t bytes = SDL_min(src_bytes, dst_bytes - 1);
  506. size_t i = 0;
  507. char trailing_bytes = 0;
  508. if (bytes)
  509. {
  510. unsigned char c = (unsigned char)src[bytes - 1];
  511. if (UTF8_IsLeadByte(c))
  512. --bytes;
  513. else if (UTF8_IsTrailingByte(c))
  514. {
  515. for (i = bytes - 1; i != 0; --i)
  516. {
  517. c = (unsigned char)src[i];
  518. trailing_bytes = UTF8_TrailingBytes(c);
  519. if (trailing_bytes)
  520. {
  521. if (bytes - i != trailing_bytes + 1)
  522. bytes = i;
  523. break;
  524. }
  525. }
  526. }
  527. SDL_memcpy(dst, src, bytes);
  528. }
  529. dst[bytes] = '\0';
  530. return bytes;
  531. }
  532. size_t
  533. SDL_utf8strlen(const char *str)
  534. {
  535. size_t retval = 0;
  536. const char *p = str;
  537. char ch;
  538. while ((ch = *(p++)) != 0) {
  539. /* if top two bits are 1 and 0, it's a continuation byte. */
  540. if ((ch & 0xc0) != 0x80) {
  541. retval++;
  542. }
  543. }
  544. return retval;
  545. }
  546. size_t
  547. SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen)
  548. {
  549. #if defined(HAVE_STRLCAT)
  550. return strlcat(dst, src, maxlen);
  551. #else
  552. size_t dstlen = SDL_strlen(dst);
  553. size_t srclen = SDL_strlen(src);
  554. if (dstlen < maxlen) {
  555. SDL_strlcpy(dst + dstlen, src, maxlen - dstlen);
  556. }
  557. return dstlen + srclen;
  558. #endif /* HAVE_STRLCAT */
  559. }
  560. char *
  561. SDL_strdup(const char *string)
  562. {
  563. size_t len = SDL_strlen(string) + 1;
  564. char *newstr = (char *)SDL_malloc(len);
  565. if (newstr) {
  566. SDL_memcpy(newstr, string, len);
  567. }
  568. return newstr;
  569. }
  570. char *
  571. SDL_strrev(char *string)
  572. {
  573. #if defined(HAVE__STRREV)
  574. return _strrev(string);
  575. #else
  576. size_t len = SDL_strlen(string);
  577. char *a = &string[0];
  578. char *b = &string[len - 1];
  579. len /= 2;
  580. while (len--) {
  581. char c = *a;
  582. *a++ = *b;
  583. *b-- = c;
  584. }
  585. return string;
  586. #endif /* HAVE__STRREV */
  587. }
  588. char *
  589. SDL_strupr(char *string)
  590. {
  591. #if defined(HAVE__STRUPR)
  592. return _strupr(string);
  593. #else
  594. char *bufp = string;
  595. while (*bufp) {
  596. *bufp = SDL_toupper((unsigned char) *bufp);
  597. ++bufp;
  598. }
  599. return string;
  600. #endif /* HAVE__STRUPR */
  601. }
  602. char *
  603. SDL_strlwr(char *string)
  604. {
  605. #if defined(HAVE__STRLWR)
  606. return _strlwr(string);
  607. #else
  608. char *bufp = string;
  609. while (*bufp) {
  610. *bufp = SDL_tolower((unsigned char) *bufp);
  611. ++bufp;
  612. }
  613. return string;
  614. #endif /* HAVE__STRLWR */
  615. }
  616. char *
  617. SDL_strchr(const char *string, int c)
  618. {
  619. #ifdef HAVE_STRCHR
  620. return SDL_const_cast(char*,strchr(string, c));
  621. #elif defined(HAVE_INDEX)
  622. return SDL_const_cast(char*,index(string, c));
  623. #else
  624. while (*string) {
  625. if (*string == c) {
  626. return (char *) string;
  627. }
  628. ++string;
  629. }
  630. return NULL;
  631. #endif /* HAVE_STRCHR */
  632. }
  633. char *
  634. SDL_strrchr(const char *string, int c)
  635. {
  636. #ifdef HAVE_STRRCHR
  637. return SDL_const_cast(char*,strrchr(string, c));
  638. #elif defined(HAVE_RINDEX)
  639. return SDL_const_cast(char*,rindex(string, c));
  640. #else
  641. const char *bufp = string + SDL_strlen(string) - 1;
  642. while (bufp >= string) {
  643. if (*bufp == c) {
  644. return (char *) bufp;
  645. }
  646. --bufp;
  647. }
  648. return NULL;
  649. #endif /* HAVE_STRRCHR */
  650. }
  651. char *
  652. SDL_strstr(const char *haystack, const char *needle)
  653. {
  654. #if defined(HAVE_STRSTR)
  655. return SDL_const_cast(char*,strstr(haystack, needle));
  656. #else
  657. size_t length = SDL_strlen(needle);
  658. while (*haystack) {
  659. if (SDL_strncmp(haystack, needle, length) == 0) {
  660. return (char *) haystack;
  661. }
  662. ++haystack;
  663. }
  664. return NULL;
  665. #endif /* HAVE_STRSTR */
  666. }
  667. #if !defined(HAVE__LTOA) || !defined(HAVE__I64TOA) || \
  668. !defined(HAVE__ULTOA) || !defined(HAVE__UI64TOA)
  669. static const char ntoa_table[] = {
  670. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  671. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  672. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  673. 'U', 'V', 'W', 'X', 'Y', 'Z'
  674. };
  675. #endif /* ntoa() conversion table */
  676. char *
  677. SDL_itoa(int value, char *string, int radix)
  678. {
  679. #ifdef HAVE_ITOA
  680. return itoa(value, string, radix);
  681. #else
  682. return SDL_ltoa((long)value, string, radix);
  683. #endif /* HAVE_ITOA */
  684. }
  685. char *
  686. SDL_uitoa(unsigned int value, char *string, int radix)
  687. {
  688. #ifdef HAVE__UITOA
  689. return _uitoa(value, string, radix);
  690. #else
  691. return SDL_ultoa((unsigned long)value, string, radix);
  692. #endif /* HAVE__UITOA */
  693. }
  694. char *
  695. SDL_ltoa(long value, char *string, int radix)
  696. {
  697. #if defined(HAVE__LTOA)
  698. return _ltoa(value, string, radix);
  699. #else
  700. char *bufp = string;
  701. if (value < 0) {
  702. *bufp++ = '-';
  703. SDL_ultoa(-value, bufp, radix);
  704. } else {
  705. SDL_ultoa(value, bufp, radix);
  706. }
  707. return string;
  708. #endif /* HAVE__LTOA */
  709. }
  710. char *
  711. SDL_ultoa(unsigned long value, char *string, int radix)
  712. {
  713. #if defined(HAVE__ULTOA)
  714. return _ultoa(value, string, radix);
  715. #else
  716. char *bufp = string;
  717. if (value) {
  718. while (value > 0) {
  719. *bufp++ = ntoa_table[value % radix];
  720. value /= radix;
  721. }
  722. } else {
  723. *bufp++ = '0';
  724. }
  725. *bufp = '\0';
  726. /* The numbers went into the string backwards. :) */
  727. SDL_strrev(string);
  728. return string;
  729. #endif /* HAVE__ULTOA */
  730. }
  731. char *
  732. SDL_lltoa(Sint64 value, char *string, int radix)
  733. {
  734. #if defined(HAVE__I64TOA)
  735. return _i64toa(value, string, radix);
  736. #else
  737. char *bufp = string;
  738. if (value < 0) {
  739. *bufp++ = '-';
  740. SDL_ulltoa(-value, bufp, radix);
  741. } else {
  742. SDL_ulltoa(value, bufp, radix);
  743. }
  744. return string;
  745. #endif /* HAVE__I64TOA */
  746. }
  747. char *
  748. SDL_ulltoa(Uint64 value, char *string, int radix)
  749. {
  750. #if defined(HAVE__UI64TOA)
  751. return _ui64toa(value, string, radix);
  752. #else
  753. char *bufp = string;
  754. if (value) {
  755. while (value > 0) {
  756. *bufp++ = ntoa_table[value % radix];
  757. value /= radix;
  758. }
  759. } else {
  760. *bufp++ = '0';
  761. }
  762. *bufp = '\0';
  763. /* The numbers went into the string backwards. :) */
  764. SDL_strrev(string);
  765. return string;
  766. #endif /* HAVE__UI64TOA */
  767. }
  768. int SDL_atoi(const char *string)
  769. {
  770. #ifdef HAVE_ATOI
  771. return atoi(string);
  772. #else
  773. return SDL_strtol(string, NULL, 0);
  774. #endif /* HAVE_ATOI */
  775. }
  776. double SDL_atof(const char *string)
  777. {
  778. #ifdef HAVE_ATOF
  779. return atof(string);
  780. #else
  781. return SDL_strtod(string, NULL);
  782. #endif /* HAVE_ATOF */
  783. }
  784. long
  785. SDL_strtol(const char *string, char **endp, int base)
  786. {
  787. #if defined(HAVE_STRTOL)
  788. return strtol(string, endp, base);
  789. #else
  790. size_t len;
  791. long value = 0;
  792. if (!base) {
  793. if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
  794. base = 16;
  795. } else {
  796. base = 10;
  797. }
  798. }
  799. len = SDL_ScanLong(string, base, &value);
  800. if (endp) {
  801. *endp = (char *) string + len;
  802. }
  803. return value;
  804. #endif /* HAVE_STRTOL */
  805. }
  806. unsigned long
  807. SDL_strtoul(const char *string, char **endp, int base)
  808. {
  809. #if defined(HAVE_STRTOUL)
  810. return strtoul(string, endp, base);
  811. #else
  812. size_t len;
  813. unsigned long value = 0;
  814. if (!base) {
  815. if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
  816. base = 16;
  817. } else {
  818. base = 10;
  819. }
  820. }
  821. len = SDL_ScanUnsignedLong(string, base, &value);
  822. if (endp) {
  823. *endp = (char *) string + len;
  824. }
  825. return value;
  826. #endif /* HAVE_STRTOUL */
  827. }
  828. Sint64
  829. SDL_strtoll(const char *string, char **endp, int base)
  830. {
  831. #if defined(HAVE_STRTOLL)
  832. return strtoll(string, endp, base);
  833. #else
  834. size_t len;
  835. Sint64 value = 0;
  836. if (!base) {
  837. if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
  838. base = 16;
  839. } else {
  840. base = 10;
  841. }
  842. }
  843. len = SDL_ScanLongLong(string, base, &value);
  844. if (endp) {
  845. *endp = (char *) string + len;
  846. }
  847. return value;
  848. #endif /* HAVE_STRTOLL */
  849. }
  850. Uint64
  851. SDL_strtoull(const char *string, char **endp, int base)
  852. {
  853. #if defined(HAVE_STRTOULL)
  854. return strtoull(string, endp, base);
  855. #else
  856. size_t len;
  857. Uint64 value = 0;
  858. if (!base) {
  859. if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
  860. base = 16;
  861. } else {
  862. base = 10;
  863. }
  864. }
  865. len = SDL_ScanUnsignedLongLong(string, base, &value);
  866. if (endp) {
  867. *endp = (char *) string + len;
  868. }
  869. return value;
  870. #endif /* HAVE_STRTOULL */
  871. }
  872. double
  873. SDL_strtod(const char *string, char **endp)
  874. {
  875. #if defined(HAVE_STRTOD)
  876. return strtod(string, endp);
  877. #else
  878. size_t len;
  879. double value = 0.0;
  880. len = SDL_ScanFloat(string, &value);
  881. if (endp) {
  882. *endp = (char *) string + len;
  883. }
  884. return value;
  885. #endif /* HAVE_STRTOD */
  886. }
  887. int
  888. SDL_strcmp(const char *str1, const char *str2)
  889. {
  890. #if defined(HAVE_STRCMP)
  891. return strcmp(str1, str2);
  892. #else
  893. while (*str1 && *str2) {
  894. if (*str1 != *str2)
  895. break;
  896. ++str1;
  897. ++str2;
  898. }
  899. return (int)((unsigned char) *str1 - (unsigned char) *str2);
  900. #endif /* HAVE_STRCMP */
  901. }
  902. int
  903. SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
  904. {
  905. #if defined(HAVE_STRNCMP)
  906. return strncmp(str1, str2, maxlen);
  907. #else
  908. while (*str1 && *str2 && maxlen) {
  909. if (*str1 != *str2)
  910. break;
  911. ++str1;
  912. ++str2;
  913. --maxlen;
  914. }
  915. if (!maxlen) {
  916. return 0;
  917. }
  918. return (int) ((unsigned char) *str1 - (unsigned char) *str2);
  919. #endif /* HAVE_STRNCMP */
  920. }
  921. int
  922. SDL_strcasecmp(const char *str1, const char *str2)
  923. {
  924. #ifdef HAVE_STRCASECMP
  925. return strcasecmp(str1, str2);
  926. #elif defined(HAVE__STRICMP)
  927. return _stricmp(str1, str2);
  928. #else
  929. char a = 0;
  930. char b = 0;
  931. while (*str1 && *str2) {
  932. a = SDL_toupper((unsigned char) *str1);
  933. b = SDL_toupper((unsigned char) *str2);
  934. if (a != b)
  935. break;
  936. ++str1;
  937. ++str2;
  938. }
  939. a = SDL_toupper(*str1);
  940. b = SDL_toupper(*str2);
  941. return (int) ((unsigned char) a - (unsigned char) b);
  942. #endif /* HAVE_STRCASECMP */
  943. }
  944. int
  945. SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
  946. {
  947. #ifdef HAVE_STRNCASECMP
  948. return strncasecmp(str1, str2, maxlen);
  949. #elif defined(HAVE__STRNICMP)
  950. return _strnicmp(str1, str2, maxlen);
  951. #else
  952. char a = 0;
  953. char b = 0;
  954. while (*str1 && *str2 && maxlen) {
  955. a = SDL_tolower((unsigned char) *str1);
  956. b = SDL_tolower((unsigned char) *str2);
  957. if (a != b)
  958. break;
  959. ++str1;
  960. ++str2;
  961. --maxlen;
  962. }
  963. if (maxlen == 0) {
  964. return 0;
  965. } else {
  966. a = SDL_tolower((unsigned char) *str1);
  967. b = SDL_tolower((unsigned char) *str2);
  968. return (int) ((unsigned char) a - (unsigned char) b);
  969. }
  970. #endif /* HAVE_STRNCASECMP */
  971. }
  972. int
  973. SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...)
  974. {
  975. int rc;
  976. va_list ap;
  977. va_start(ap, fmt);
  978. rc = SDL_vsscanf(text, fmt, ap);
  979. va_end(ap);
  980. return rc;
  981. }
  982. #ifdef HAVE_VSSCANF
  983. int
  984. SDL_vsscanf(const char *text, const char *fmt, va_list ap)
  985. {
  986. return vsscanf(text, fmt, ap);
  987. }
  988. #else
  989. int
  990. SDL_vsscanf(const char *text, const char *fmt, va_list ap)
  991. {
  992. int retval = 0;
  993. if (!text || !*text) {
  994. return -1;
  995. }
  996. while (*fmt) {
  997. if (*fmt == ' ') {
  998. while (SDL_isspace((unsigned char) *text)) {
  999. ++text;
  1000. }
  1001. ++fmt;
  1002. continue;
  1003. }
  1004. if (*fmt == '%') {
  1005. SDL_bool done = SDL_FALSE;
  1006. long count = 0;
  1007. int radix = 10;
  1008. enum
  1009. {
  1010. DO_SHORT,
  1011. DO_INT,
  1012. DO_LONG,
  1013. DO_LONGLONG
  1014. } inttype = DO_INT;
  1015. size_t advance;
  1016. SDL_bool suppress = SDL_FALSE;
  1017. ++fmt;
  1018. if (*fmt == '%') {
  1019. if (*text == '%') {
  1020. ++text;
  1021. ++fmt;
  1022. continue;
  1023. }
  1024. break;
  1025. }
  1026. if (*fmt == '*') {
  1027. suppress = SDL_TRUE;
  1028. ++fmt;
  1029. }
  1030. fmt += SDL_ScanLong(fmt, 10, &count);
  1031. if (*fmt == 'c') {
  1032. if (!count) {
  1033. count = 1;
  1034. }
  1035. if (suppress) {
  1036. while (count--) {
  1037. ++text;
  1038. }
  1039. } else {
  1040. char *valuep = va_arg(ap, char *);
  1041. while (count--) {
  1042. *valuep++ = *text++;
  1043. }
  1044. ++retval;
  1045. }
  1046. continue;
  1047. }
  1048. while (SDL_isspace((unsigned char) *text)) {
  1049. ++text;
  1050. }
  1051. /* FIXME: implement more of the format specifiers */
  1052. while (!done) {
  1053. switch (*fmt) {
  1054. case '*':
  1055. suppress = SDL_TRUE;
  1056. break;
  1057. case 'h':
  1058. if (inttype > DO_SHORT) {
  1059. ++inttype;
  1060. }
  1061. break;
  1062. case 'l':
  1063. if (inttype < DO_LONGLONG) {
  1064. ++inttype;
  1065. }
  1066. break;
  1067. case 'I':
  1068. if (SDL_strncmp(fmt, "I64", 3) == 0) {
  1069. fmt += 2;
  1070. inttype = DO_LONGLONG;
  1071. }
  1072. break;
  1073. case 'i':
  1074. {
  1075. int index = 0;
  1076. if (text[index] == '-') {
  1077. ++index;
  1078. }
  1079. if (text[index] == '0') {
  1080. if (SDL_tolower((unsigned char) text[index + 1]) == 'x') {
  1081. radix = 16;
  1082. } else {
  1083. radix = 8;
  1084. }
  1085. }
  1086. }
  1087. /* Fall through to %d handling */
  1088. case 'd':
  1089. if (inttype == DO_LONGLONG) {
  1090. Sint64 value;
  1091. advance = SDL_ScanLongLong(text, radix, &value);
  1092. text += advance;
  1093. if (advance && !suppress) {
  1094. Sint64 *valuep = va_arg(ap, Sint64 *);
  1095. *valuep = value;
  1096. ++retval;
  1097. }
  1098. } else {
  1099. long value;
  1100. advance = SDL_ScanLong(text, radix, &value);
  1101. text += advance;
  1102. if (advance && !suppress) {
  1103. switch (inttype) {
  1104. case DO_SHORT:
  1105. {
  1106. short *valuep = va_arg(ap, short *);
  1107. *valuep = (short) value;
  1108. }
  1109. break;
  1110. case DO_INT:
  1111. {
  1112. int *valuep = va_arg(ap, int *);
  1113. *valuep = (int) value;
  1114. }
  1115. break;
  1116. case DO_LONG:
  1117. {
  1118. long *valuep = va_arg(ap, long *);
  1119. *valuep = value;
  1120. }
  1121. break;
  1122. case DO_LONGLONG:
  1123. /* Handled above */
  1124. break;
  1125. }
  1126. ++retval;
  1127. }
  1128. }
  1129. done = SDL_TRUE;
  1130. break;
  1131. case 'o':
  1132. if (radix == 10) {
  1133. radix = 8;
  1134. }
  1135. /* Fall through to unsigned handling */
  1136. case 'x':
  1137. case 'X':
  1138. if (radix == 10) {
  1139. radix = 16;
  1140. }
  1141. /* Fall through to unsigned handling */
  1142. case 'u':
  1143. if (inttype == DO_LONGLONG) {
  1144. Uint64 value = 0;
  1145. advance = SDL_ScanUnsignedLongLong(text, radix, &value);
  1146. text += advance;
  1147. if (advance && !suppress) {
  1148. Uint64 *valuep = va_arg(ap, Uint64 *);
  1149. *valuep = value;
  1150. ++retval;
  1151. }
  1152. } else {
  1153. unsigned long value = 0;
  1154. advance = SDL_ScanUnsignedLong(text, radix, &value);
  1155. text += advance;
  1156. if (advance && !suppress) {
  1157. switch (inttype) {
  1158. case DO_SHORT:
  1159. {
  1160. short *valuep = va_arg(ap, short *);
  1161. *valuep = (short) value;
  1162. }
  1163. break;
  1164. case DO_INT:
  1165. {
  1166. int *valuep = va_arg(ap, int *);
  1167. *valuep = (int) value;
  1168. }
  1169. break;
  1170. case DO_LONG:
  1171. {
  1172. long *valuep = va_arg(ap, long *);
  1173. *valuep = value;
  1174. }
  1175. break;
  1176. case DO_LONGLONG:
  1177. /* Handled above */
  1178. break;
  1179. }
  1180. ++retval;
  1181. }
  1182. }
  1183. done = SDL_TRUE;
  1184. break;
  1185. case 'p':
  1186. {
  1187. uintptr_t value = 0;
  1188. advance = SDL_ScanUintPtrT(text, 16, &value);
  1189. text += advance;
  1190. if (advance && !suppress) {
  1191. void **valuep = va_arg(ap, void **);
  1192. *valuep = (void *) value;
  1193. ++retval;
  1194. }
  1195. }
  1196. done = SDL_TRUE;
  1197. break;
  1198. case 'f':
  1199. {
  1200. double value;
  1201. advance = SDL_ScanFloat(text, &value);
  1202. text += advance;
  1203. if (advance && !suppress) {
  1204. float *valuep = va_arg(ap, float *);
  1205. *valuep = (float) value;
  1206. ++retval;
  1207. }
  1208. }
  1209. done = SDL_TRUE;
  1210. break;
  1211. case 's':
  1212. if (suppress) {
  1213. while (!SDL_isspace((unsigned char) *text)) {
  1214. ++text;
  1215. if (count) {
  1216. if (--count == 0) {
  1217. break;
  1218. }
  1219. }
  1220. }
  1221. } else {
  1222. char *valuep = va_arg(ap, char *);
  1223. while (!SDL_isspace((unsigned char) *text)) {
  1224. *valuep++ = *text++;
  1225. if (count) {
  1226. if (--count == 0) {
  1227. break;
  1228. }
  1229. }
  1230. }
  1231. *valuep = '\0';
  1232. ++retval;
  1233. }
  1234. done = SDL_TRUE;
  1235. break;
  1236. default:
  1237. done = SDL_TRUE;
  1238. break;
  1239. }
  1240. ++fmt;
  1241. }
  1242. continue;
  1243. }
  1244. if (*text == *fmt) {
  1245. ++text;
  1246. ++fmt;
  1247. continue;
  1248. }
  1249. /* Text didn't match format specifier */
  1250. break;
  1251. }
  1252. return retval;
  1253. }
  1254. #endif /* HAVE_VSSCANF */
  1255. int
  1256. SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
  1257. {
  1258. va_list ap;
  1259. int retval;
  1260. va_start(ap, fmt);
  1261. retval = SDL_vsnprintf(text, maxlen, fmt, ap);
  1262. va_end(ap);
  1263. return retval;
  1264. }
  1265. #if defined(HAVE_LIBC) && defined(__WATCOMC__)
  1266. /* _vsnprintf() doesn't ensure nul termination */
  1267. int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)
  1268. {
  1269. int retval;
  1270. if (!fmt) fmt = "";
  1271. retval = _vsnprintf(text, maxlen, fmt, ap);
  1272. if (maxlen > 0) text[maxlen-1] = '\0';
  1273. if (retval < 0) retval = (int) maxlen;
  1274. return retval;
  1275. }
  1276. #elif defined(HAVE_VSNPRINTF)
  1277. int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)
  1278. {
  1279. if (!fmt) {
  1280. fmt = "";
  1281. }
  1282. return vsnprintf(text, maxlen, fmt, ap);
  1283. }
  1284. #else
  1285. /* FIXME: implement more of the format specifiers */
  1286. typedef enum
  1287. {
  1288. SDL_CASE_NOCHANGE,
  1289. SDL_CASE_LOWER,
  1290. SDL_CASE_UPPER
  1291. } SDL_letter_case;
  1292. typedef struct
  1293. {
  1294. SDL_bool left_justify; /* for now: ignored. */
  1295. SDL_bool force_sign;
  1296. SDL_bool force_type; /* for now: used only by float printer, ignored otherwise. */
  1297. SDL_bool pad_zeroes;
  1298. SDL_letter_case force_case;
  1299. int width;
  1300. int radix;
  1301. int precision;
  1302. } SDL_FormatInfo;
  1303. static size_t
  1304. SDL_PrintString(char *text, size_t maxlen, SDL_FormatInfo *info, const char *string)
  1305. {
  1306. size_t length = 0;
  1307. size_t slen, sz;
  1308. if (string == NULL) {
  1309. string = "(null)";
  1310. }
  1311. sz = SDL_strlen(string);
  1312. if (info && info->width > 0 && (size_t)info->width > sz) {
  1313. const char fill = info->pad_zeroes ? '0' : ' ';
  1314. size_t width = info->width - sz;
  1315. size_t filllen;
  1316. if (info->precision >= 0 && (size_t)info->precision < sz)
  1317. width += sz - (size_t)info->precision;
  1318. filllen = SDL_min(width, maxlen);
  1319. SDL_memset(text, fill, filllen);
  1320. text += filllen;
  1321. length += filllen;
  1322. maxlen -= filllen;
  1323. }
  1324. slen = SDL_strlcpy(text, string, maxlen);
  1325. length += SDL_min(slen, maxlen);
  1326. if (info) {
  1327. if (info->precision >= 0 && (size_t)info->precision < sz) {
  1328. slen = (size_t)info->precision;
  1329. if (slen < maxlen) {
  1330. text[slen] = 0;
  1331. length -= (sz - slen);
  1332. }
  1333. }
  1334. if (info->force_case == SDL_CASE_LOWER) {
  1335. SDL_strlwr(text);
  1336. } else if (info->force_case == SDL_CASE_UPPER) {
  1337. SDL_strupr(text);
  1338. }
  1339. }
  1340. return length;
  1341. }
  1342. static void
  1343. SDL_IntPrecisionAdjust(char *num, size_t maxlen, SDL_FormatInfo *info)
  1344. {/* left-pad num with zeroes. */
  1345. size_t sz, pad, have_sign;
  1346. if (!info)
  1347. return;
  1348. have_sign = 0;
  1349. if (*num == '-' || *num == '+') {
  1350. have_sign = 1;
  1351. ++num;
  1352. --maxlen;
  1353. }
  1354. sz = SDL_strlen(num);
  1355. if (info->precision > 0 && sz < (size_t)info->precision) {
  1356. pad = (size_t)info->precision - sz;
  1357. if (pad + sz + 1 <= maxlen) { /* otherwise ignore the precision */
  1358. SDL_memmove(num + pad, num, sz + 1);
  1359. SDL_memset(num, '0', pad);
  1360. }
  1361. }
  1362. info->precision = -1;/* so that SDL_PrintString() doesn't make a mess. */
  1363. if (info->pad_zeroes && info->width > 0 && (size_t)info->width > sz + have_sign) {
  1364. /* handle here: spaces are added before the sign
  1365. but zeroes must be placed _after_ the sign. */
  1366. /* sz hasn't changed: we ignore pad_zeroes if a precision is given. */
  1367. pad = (size_t)info->width - sz - have_sign;
  1368. if (pad + sz + 1 <= maxlen) {
  1369. SDL_memmove(num + pad, num, sz + 1);
  1370. SDL_memset(num, '0', pad);
  1371. }
  1372. info->width = 0; /* so that SDL_PrintString() doesn't make a mess. */
  1373. }
  1374. }
  1375. static size_t
  1376. SDL_PrintLong(char *text, size_t maxlen, SDL_FormatInfo *info, long value)
  1377. {
  1378. char num[130], *p = num;
  1379. if (info->force_sign && value >= 0L) {
  1380. *p++ = '+';
  1381. }
  1382. SDL_ltoa(value, p, info ? info->radix : 10);
  1383. SDL_IntPrecisionAdjust(num, maxlen, info);
  1384. return SDL_PrintString(text, maxlen, info, num);
  1385. }
  1386. static size_t
  1387. SDL_PrintUnsignedLong(char *text, size_t maxlen, SDL_FormatInfo *info, unsigned long value)
  1388. {
  1389. char num[130];
  1390. SDL_ultoa(value, num, info ? info->radix : 10);
  1391. SDL_IntPrecisionAdjust(num, maxlen, info);
  1392. return SDL_PrintString(text, maxlen, info, num);
  1393. }
  1394. static size_t
  1395. SDL_PrintLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, Sint64 value)
  1396. {
  1397. char num[130], *p = num;
  1398. if (info->force_sign && value >= (Sint64)0) {
  1399. *p++ = '+';
  1400. }
  1401. SDL_lltoa(value, p, info ? info->radix : 10);
  1402. SDL_IntPrecisionAdjust(num, maxlen, info);
  1403. return SDL_PrintString(text, maxlen, info, num);
  1404. }
  1405. static size_t
  1406. SDL_PrintUnsignedLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, Uint64 value)
  1407. {
  1408. char num[130];
  1409. SDL_ulltoa(value, num, info ? info->radix : 10);
  1410. SDL_IntPrecisionAdjust(num, maxlen, info);
  1411. return SDL_PrintString(text, maxlen, info, num);
  1412. }
  1413. static size_t
  1414. SDL_PrintFloat(char *text, size_t maxlen, SDL_FormatInfo *info, double arg)
  1415. {
  1416. int width;
  1417. size_t len;
  1418. size_t left = maxlen;
  1419. char *textstart = text;
  1420. if (arg) {
  1421. /* This isn't especially accurate, but hey, it's easy. :) */
  1422. unsigned long value;
  1423. if (arg < 0) {
  1424. if (left > 1) {
  1425. *text = '-';
  1426. --left;
  1427. }
  1428. ++text;
  1429. arg = -arg;
  1430. } else if (info->force_sign) {
  1431. if (left > 1) {
  1432. *text = '+';
  1433. --left;
  1434. }
  1435. ++text;
  1436. }
  1437. value = (unsigned long) arg;
  1438. len = SDL_PrintUnsignedLong(text, left, NULL, value);
  1439. if (len >= left) {
  1440. text += (left > 1) ? left - 1 : 0;
  1441. left = SDL_min(left, 1);
  1442. } else {
  1443. text += len;
  1444. left -= len;
  1445. }
  1446. arg -= value;
  1447. if (info->precision < 0) {
  1448. info->precision = 6;
  1449. }
  1450. if (info->force_type || info->precision > 0) {
  1451. int mult = 10;
  1452. if (left > 1) {
  1453. *text = '.';
  1454. --left;
  1455. }
  1456. ++text;
  1457. while (info->precision-- > 0) {
  1458. value = (unsigned long) (arg * mult);
  1459. len = SDL_PrintUnsignedLong(text, left, NULL, value);
  1460. if (len >= left) {
  1461. text += (left > 1) ? left - 1 : 0;
  1462. left = SDL_min(left, 1);
  1463. } else {
  1464. text += len;
  1465. left -= len;
  1466. }
  1467. arg -= (double) value / mult;
  1468. mult *= 10;
  1469. }
  1470. }
  1471. } else {
  1472. if (left > 1) {
  1473. *text = '0';
  1474. --left;
  1475. }
  1476. ++text;
  1477. if (info->force_type) {
  1478. if (left > 1) {
  1479. *text = '.';
  1480. --left;
  1481. }
  1482. ++text;
  1483. }
  1484. }
  1485. width = info->width - (int)(text - textstart);
  1486. if (width > 0) {
  1487. const char fill = info->pad_zeroes ? '0' : ' ';
  1488. char *end = text+left-1;
  1489. len = (text - textstart);
  1490. for (len = (text - textstart); len--; ) {
  1491. if ((textstart+len+width) < end) {
  1492. *(textstart+len+width) = *(textstart+len);
  1493. }
  1494. }
  1495. len = (size_t)width;
  1496. if (len >= left) {
  1497. text += (left > 1) ? left - 1 : 0;
  1498. left = SDL_min(left, 1);
  1499. } else {
  1500. text += len;
  1501. left -= len;
  1502. }
  1503. if (end != textstart) {
  1504. const size_t filllen = SDL_min(len, ((size_t) (end - textstart)) - 1);
  1505. SDL_memset(textstart, fill, filllen);
  1506. }
  1507. }
  1508. return (text - textstart);
  1509. }
  1510. int
  1511. SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)
  1512. {
  1513. size_t left = maxlen;
  1514. char *textstart = text;
  1515. if (!fmt) {
  1516. fmt = "";
  1517. }
  1518. while (*fmt && left > 1) {
  1519. if (*fmt == '%') {
  1520. SDL_bool done = SDL_FALSE;
  1521. size_t len = 0;
  1522. SDL_bool check_flag;
  1523. SDL_FormatInfo info;
  1524. enum
  1525. {
  1526. DO_INT,
  1527. DO_LONG,
  1528. DO_LONGLONG
  1529. } inttype = DO_INT;
  1530. SDL_zero(info);
  1531. info.radix = 10;
  1532. info.precision = -1;
  1533. check_flag = SDL_TRUE;
  1534. while (check_flag) {
  1535. ++fmt;
  1536. switch (*fmt) {
  1537. case '-':
  1538. info.left_justify = SDL_TRUE;
  1539. break;
  1540. case '+':
  1541. info.force_sign = SDL_TRUE;
  1542. break;
  1543. case '#':
  1544. info.force_type = SDL_TRUE;
  1545. break;
  1546. case '0':
  1547. info.pad_zeroes = SDL_TRUE;
  1548. break;
  1549. default:
  1550. check_flag = SDL_FALSE;
  1551. break;
  1552. }
  1553. }
  1554. if (*fmt >= '0' && *fmt <= '9') {
  1555. info.width = SDL_strtol(fmt, (char **)&fmt, 0);
  1556. }
  1557. else if (*fmt == '*') {
  1558. ++fmt;
  1559. info.width = va_arg(ap, int);
  1560. }
  1561. if (*fmt == '.') {
  1562. ++fmt;
  1563. if (*fmt >= '0' && *fmt <= '9') {
  1564. info.precision = SDL_strtol(fmt, (char **)&fmt, 0);
  1565. } else if (*fmt == '*') {
  1566. ++fmt;
  1567. info.precision = va_arg(ap, int);
  1568. } else {
  1569. info.precision = 0;
  1570. }
  1571. if (info.precision < 0) {
  1572. info.precision = 0;
  1573. }
  1574. }
  1575. while (!done) {
  1576. switch (*fmt) {
  1577. case '%':
  1578. if (left > 1) {
  1579. *text = '%';
  1580. }
  1581. len = 1;
  1582. done = SDL_TRUE;
  1583. break;
  1584. case 'c':
  1585. /* char is promoted to int when passed through (...) */
  1586. if (left > 1) {
  1587. *text = (char) va_arg(ap, int);
  1588. }
  1589. len = 1;
  1590. done = SDL_TRUE;
  1591. break;
  1592. case 'h':
  1593. /* short is promoted to int when passed through (...) */
  1594. break;
  1595. case 'l':
  1596. if (inttype < DO_LONGLONG) {
  1597. ++inttype;
  1598. }
  1599. break;
  1600. case 'I':
  1601. if (SDL_strncmp(fmt, "I64", 3) == 0) {
  1602. fmt += 2;
  1603. inttype = DO_LONGLONG;
  1604. }
  1605. break;
  1606. case 'i':
  1607. case 'd':
  1608. if (info.precision >= 0) {
  1609. info.pad_zeroes = SDL_FALSE;
  1610. }
  1611. switch (inttype) {
  1612. case DO_INT:
  1613. len = SDL_PrintLong(text, left, &info,
  1614. (long) va_arg(ap, int));
  1615. break;
  1616. case DO_LONG:
  1617. len = SDL_PrintLong(text, left, &info,
  1618. va_arg(ap, long));
  1619. break;
  1620. case DO_LONGLONG:
  1621. len = SDL_PrintLongLong(text, left, &info,
  1622. va_arg(ap, Sint64));
  1623. break;
  1624. }
  1625. done = SDL_TRUE;
  1626. break;
  1627. case 'p':
  1628. case 'x':
  1629. info.force_case = SDL_CASE_LOWER;
  1630. /* Fall through to 'X' handling */
  1631. case 'X':
  1632. if (info.force_case == SDL_CASE_NOCHANGE) {
  1633. info.force_case = SDL_CASE_UPPER;
  1634. }
  1635. if (info.radix == 10) {
  1636. info.radix = 16;
  1637. }
  1638. if (*fmt == 'p') {
  1639. inttype = DO_LONG;
  1640. }
  1641. /* Fall through to unsigned handling */
  1642. case 'o':
  1643. if (info.radix == 10) {
  1644. info.radix = 8;
  1645. }
  1646. /* Fall through to unsigned handling */
  1647. case 'u':
  1648. info.force_sign = SDL_FALSE;
  1649. if (info.precision >= 0) {
  1650. info.pad_zeroes = SDL_FALSE;
  1651. }
  1652. switch (inttype) {
  1653. case DO_INT:
  1654. len = SDL_PrintUnsignedLong(text, left, &info,
  1655. (unsigned long)
  1656. va_arg(ap, unsigned int));
  1657. break;
  1658. case DO_LONG:
  1659. len = SDL_PrintUnsignedLong(text, left, &info,
  1660. va_arg(ap, unsigned long));
  1661. break;
  1662. case DO_LONGLONG:
  1663. len = SDL_PrintUnsignedLongLong(text, left, &info,
  1664. va_arg(ap, Uint64));
  1665. break;
  1666. }
  1667. done = SDL_TRUE;
  1668. break;
  1669. case 'f':
  1670. len = SDL_PrintFloat(text, left, &info, va_arg(ap, double));
  1671. done = SDL_TRUE;
  1672. break;
  1673. case 'S':
  1674. {
  1675. /* In practice this is used on Windows for WCHAR strings */
  1676. wchar_t *wide_arg = va_arg(ap, wchar_t *);
  1677. char *arg = SDL_iconv_string("UTF-8", "UTF-16LE", (char *)(wide_arg), (SDL_wcslen(wide_arg)+1)*sizeof(*wide_arg));
  1678. info.pad_zeroes = SDL_FALSE;
  1679. len = SDL_PrintString(text, left, &info, arg);
  1680. SDL_free(arg);
  1681. done = SDL_TRUE;
  1682. }
  1683. break;
  1684. case 's':
  1685. info.pad_zeroes = SDL_FALSE;
  1686. len = SDL_PrintString(text, left, &info, va_arg(ap, char *));
  1687. done = SDL_TRUE;
  1688. break;
  1689. default:
  1690. done = SDL_TRUE;
  1691. break;
  1692. }
  1693. ++fmt;
  1694. }
  1695. if (len >= left) {
  1696. text += (left > 1) ? left - 1 : 0;
  1697. left = SDL_min(left, 1);
  1698. } else {
  1699. text += len;
  1700. left -= len;
  1701. }
  1702. } else {
  1703. *text++ = *fmt++;
  1704. --left;
  1705. }
  1706. }
  1707. if (left > 0) {
  1708. *text = '\0';
  1709. }
  1710. return (int)(text - textstart);
  1711. }
  1712. #endif /* HAVE_VSNPRINTF */
  1713. /* vi: set ts=4 sw=4 expandtab: */