Add macros for generic atomic functionality
[openal-soft.git] / Alc / helpers.c
blob28efc82e6c316169e6639a714ae7830b23773aef
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 2011 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
21 #ifdef _WIN32
22 #ifdef __MINGW32__
23 #define _WIN32_IE 0x501
24 #else
25 #define _WIN32_IE 0x400
26 #endif
27 #endif
29 #include "config.h"
31 #include <stdlib.h>
32 #include <time.h>
33 #include <errno.h>
34 #include <stdarg.h>
35 #ifdef HAVE_MALLOC_H
36 #include <malloc.h>
37 #endif
39 #ifndef AL_NO_UID_DEFS
40 #if defined(HAVE_GUIDDEF_H) || defined(HAVE_INITGUID_H)
41 #define INITGUID
42 #include <windows.h>
43 #ifdef HAVE_GUIDDEF_H
44 #include <guiddef.h>
45 #else
46 #include <initguid.h>
47 #endif
49 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
50 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80,0x00, 0x00,0xaa,0x00,0x38,0x9b,0x71);
52 DEFINE_GUID(IID_IDirectSoundNotify, 0xb0210783, 0x89cd, 0x11d0, 0xaf,0x08, 0x00,0xa0,0xc9,0x25,0xcd,0x16);
54 DEFINE_GUID(CLSID_MMDeviceEnumerator, 0xbcde0395, 0xe52f, 0x467c, 0x8e,0x3d, 0xc4,0x57,0x92,0x91,0x69,0x2e);
55 DEFINE_GUID(IID_IMMDeviceEnumerator, 0xa95664d2, 0x9614, 0x4f35, 0xa7,0x46, 0xde,0x8d,0xb6,0x36,0x17,0xe6);
56 DEFINE_GUID(IID_IAudioClient, 0x1cb9ad4c, 0xdbfa, 0x4c32, 0xb1,0x78, 0xc2,0xf5,0x68,0xa7,0x03,0xb2);
57 DEFINE_GUID(IID_IAudioRenderClient, 0xf294acfc, 0x3146, 0x4483, 0xa7,0xbf, 0xad,0xdc,0xa7,0xc2,0x60,0xe2);
59 #ifdef HAVE_MMDEVAPI
60 #include <devpropdef.h>
61 DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80,0x20, 0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
62 #endif
63 #endif
64 #endif /* AL_NO_UID_DEFS */
66 #ifdef HAVE_DLFCN_H
67 #include <dlfcn.h>
68 #endif
69 #ifdef HAVE_CPUID_H
70 #include <cpuid.h>
71 #endif
72 #ifdef HAVE_SYS_SYSCONF_H
73 #include <sys/sysconf.h>
74 #endif
75 #ifdef HAVE_FLOAT_H
76 #include <float.h>
77 #endif
78 #ifdef HAVE_IEEEFP_H
79 #include <ieeefp.h>
80 #endif
82 #ifdef _WIN32_IE
83 #include <shlobj.h>
84 #endif
86 #include "alMain.h"
87 #include "alu.h"
88 #include "atomic.h"
89 #include "uintmap.h"
90 #include "vector.h"
91 #include "alstring.h"
92 #include "compat.h"
93 #include "threads.h"
96 extern inline ALuint NextPowerOf2(ALuint value);
97 extern inline ALint fastf2i(ALfloat f);
98 extern inline ALuint fastf2u(ALfloat f);
101 ALuint CPUCapFlags = 0;
104 void FillCPUCaps(ALuint capfilter)
106 ALuint caps = 0;
108 /* FIXME: We really should get this for all available CPUs in case different
109 * CPUs have different caps (is that possible on one machine?). */
110 #if defined(HAVE_CPUID_H) && (defined(__i386__) || defined(__x86_64__) || \
111 defined(_M_IX86) || defined(_M_X64))
112 union {
113 unsigned int regs[4];
114 char str[sizeof(unsigned int[4])];
115 } cpuinf[3];
117 if(!__get_cpuid(0, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
118 ERR("Failed to get CPUID\n");
119 else
121 unsigned int maxfunc = cpuinf[0].regs[0];
122 unsigned int maxextfunc = 0;
124 if(__get_cpuid(0x80000000, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
125 maxextfunc = cpuinf[0].regs[0];
126 TRACE("Detected max CPUID function: 0x%x (ext. 0x%x)\n", maxfunc, maxextfunc);
128 TRACE("Vendor ID: \"%.4s%.4s%.4s\"\n", cpuinf[0].str+4, cpuinf[0].str+12, cpuinf[0].str+8);
129 if(maxextfunc >= 0x80000004 &&
130 __get_cpuid(0x80000002, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]) &&
131 __get_cpuid(0x80000003, &cpuinf[1].regs[0], &cpuinf[1].regs[1], &cpuinf[1].regs[2], &cpuinf[1].regs[3]) &&
132 __get_cpuid(0x80000004, &cpuinf[2].regs[0], &cpuinf[2].regs[1], &cpuinf[2].regs[2], &cpuinf[2].regs[3]))
133 TRACE("Name: \"%.16s%.16s%.16s\"\n", cpuinf[0].str, cpuinf[1].str, cpuinf[2].str);
135 if(maxfunc >= 1 &&
136 __get_cpuid(1, &cpuinf[0].regs[0], &cpuinf[0].regs[1], &cpuinf[0].regs[2], &cpuinf[0].regs[3]))
138 if((cpuinf[0].regs[3]&(1<<25)))
140 caps |= CPU_CAP_SSE;
141 if((cpuinf[0].regs[3]&(1<<26)))
143 caps |= CPU_CAP_SSE2;
144 if((cpuinf[0].regs[2]&(1<<19)))
145 caps |= CPU_CAP_SSE4_1;
150 #elif defined(HAVE_WINDOWS_H)
151 HMODULE k32 = GetModuleHandleA("kernel32.dll");
152 BOOL (WINAPI*IsProcessorFeaturePresent)(DWORD ProcessorFeature);
153 IsProcessorFeaturePresent = (BOOL(WINAPI*)(DWORD))GetProcAddress(k32, "IsProcessorFeaturePresent");
154 if(!IsProcessorFeaturePresent)
155 ERR("IsProcessorFeaturePresent not available; CPU caps not detected\n");
156 else
158 if(IsProcessorFeaturePresent(PF_XMMI_INSTRUCTIONS_AVAILABLE))
160 caps |= CPU_CAP_SSE;
161 if(IsProcessorFeaturePresent(PF_XMMI64_INSTRUCTIONS_AVAILABLE))
162 caps |= CPU_CAP_SSE2;
165 #endif
166 #ifdef HAVE_NEON
167 /* Assume Neon support if compiled with it */
168 caps |= CPU_CAP_NEON;
169 #endif
171 TRACE("Extensions:%s%s%s%s%s\n",
172 ((capfilter&CPU_CAP_SSE) ? ((caps&CPU_CAP_SSE) ? " +SSE" : " -SSE") : ""),
173 ((capfilter&CPU_CAP_SSE2) ? ((caps&CPU_CAP_SSE2) ? " +SSE2" : " -SSE2") : ""),
174 ((capfilter&CPU_CAP_SSE4_1) ? ((caps&CPU_CAP_SSE4_1) ? " +SSE4.1" : " -SSE4.1") : ""),
175 ((capfilter&CPU_CAP_NEON) ? ((caps&CPU_CAP_NEON) ? " +Neon" : " -Neon") : ""),
176 ((!capfilter) ? " -none-" : "")
178 CPUCapFlags = caps & capfilter;
182 void *al_malloc(size_t alignment, size_t size)
184 #if defined(HAVE_ALIGNED_ALLOC)
185 size = (size+(alignment-1))&~(alignment-1);
186 return aligned_alloc(alignment, size);
187 #elif defined(HAVE_POSIX_MEMALIGN)
188 void *ret;
189 if(posix_memalign(&ret, alignment, size) == 0)
190 return ret;
191 return NULL;
192 #elif defined(HAVE__ALIGNED_MALLOC)
193 return _aligned_malloc(size, alignment);
194 #else
195 char *ret = malloc(size+alignment);
196 if(ret != NULL)
198 *(ret++) = 0x00;
199 while(((ALintptrEXT)ret&(alignment-1)) != 0)
200 *(ret++) = 0x55;
202 return ret;
203 #endif
206 void *al_calloc(size_t alignment, size_t size)
208 void *ret = al_malloc(alignment, size);
209 if(ret) memset(ret, 0, size);
210 return ret;
213 void al_free(void *ptr)
215 #if defined(HAVE_ALIGNED_ALLOC) || defined(HAVE_POSIX_MEMALIGN)
216 free(ptr);
217 #elif defined(HAVE__ALIGNED_MALLOC)
218 _aligned_free(ptr);
219 #else
220 if(ptr != NULL)
222 char *finder = ptr;
223 do {
224 --finder;
225 } while(*finder == 0x55);
226 free(finder);
228 #endif
232 void SetMixerFPUMode(FPUCtl *ctl)
234 #ifdef HAVE_FENV_H
235 fegetenv(STATIC_CAST(fenv_t, ctl));
236 #if defined(__GNUC__) && defined(HAVE_SSE)
237 if((CPUCapFlags&CPU_CAP_SSE))
238 __asm__ __volatile__("stmxcsr %0" : "=m" (*&ctl->sse_state));
239 #endif
241 #ifdef FE_TOWARDZERO
242 fesetround(FE_TOWARDZERO);
243 #endif
244 #if defined(__GNUC__) && defined(HAVE_SSE)
245 if((CPUCapFlags&CPU_CAP_SSE))
247 int sseState = ctl->sse_state;
248 sseState |= 0x6000; /* set round-to-zero */
249 sseState |= 0x8000; /* set flush-to-zero */
250 if((CPUCapFlags&CPU_CAP_SSE2))
251 sseState |= 0x0040; /* set denormals-are-zero */
252 __asm__ __volatile__("ldmxcsr %0" : : "m" (*&sseState));
254 #endif
256 #elif defined(HAVE___CONTROL87_2)
258 int mode;
259 __control87_2(0, 0, &ctl->state, NULL);
260 __control87_2(_RC_CHOP, _MCW_RC, &mode, NULL);
261 #ifdef HAVE_SSE
262 if((CPUCapFlags&CPU_CAP_SSE))
264 __control87_2(0, 0, NULL, &ctl->sse_state);
265 __control87_2(_RC_CHOP|_DN_FLUSH, _MCW_RC|_MCW_DN, NULL, &mode);
267 #endif
269 #elif defined(HAVE__CONTROLFP)
271 ctl->state = _controlfp(0, 0);
272 (void)_controlfp(_RC_CHOP, _MCW_RC);
273 #endif
276 void RestoreFPUMode(const FPUCtl *ctl)
278 #ifdef HAVE_FENV_H
279 fesetenv(STATIC_CAST(fenv_t, ctl));
280 #if defined(__GNUC__) && defined(HAVE_SSE)
281 if((CPUCapFlags&CPU_CAP_SSE))
282 __asm__ __volatile__("ldmxcsr %0" : : "m" (*&ctl->sse_state));
283 #endif
285 #elif defined(HAVE___CONTROL87_2)
287 int mode;
288 __control87_2(ctl->state, _MCW_RC, &mode, NULL);
289 #ifdef HAVE_SSE
290 if((CPUCapFlags&CPU_CAP_SSE))
291 __control87_2(ctl->sse_state, _MCW_RC|_MCW_DN, NULL, &mode);
292 #endif
294 #elif defined(HAVE__CONTROLFP)
296 _controlfp(ctl->state, _MCW_RC);
297 #endif
301 #ifdef _WIN32
303 static WCHAR *FromUTF8(const char *str)
305 WCHAR *out = NULL;
306 int len;
308 if((len=MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) > 0)
310 out = calloc(sizeof(WCHAR), len);
311 MultiByteToWideChar(CP_UTF8, 0, str, -1, out, len);
313 return out;
317 void *LoadLib(const char *name)
319 HANDLE hdl = NULL;
320 WCHAR *wname;
322 wname = FromUTF8(name);
323 if(!wname)
324 ERR("Failed to convert UTF-8 filename: \"%s\"\n", name);
325 else
327 hdl = LoadLibraryW(wname);
328 free(wname);
330 return hdl;
332 void CloseLib(void *handle)
333 { FreeLibrary((HANDLE)handle); }
334 void *GetSymbol(void *handle, const char *name)
336 void *ret;
338 ret = (void*)GetProcAddress((HANDLE)handle, name);
339 if(ret == NULL)
340 ERR("Failed to load %s\n", name);
341 return ret;
344 WCHAR *strdupW(const WCHAR *str)
346 const WCHAR *n;
347 WCHAR *ret;
348 size_t len;
350 n = str;
351 while(*n) n++;
352 len = n - str;
354 ret = calloc(sizeof(WCHAR), len+1);
355 if(ret != NULL)
356 memcpy(ret, str, sizeof(WCHAR)*len);
357 return ret;
360 FILE *al_fopen(const char *fname, const char *mode)
362 WCHAR *wname=NULL, *wmode=NULL;
363 FILE *file = NULL;
365 wname = FromUTF8(fname);
366 wmode = FromUTF8(mode);
367 if(!wname)
368 ERR("Failed to convert UTF-8 filename: \"%s\"\n", fname);
369 else if(!wmode)
370 ERR("Failed to convert UTF-8 mode: \"%s\"\n", mode);
371 else
372 file = _wfopen(wname, wmode);
374 free(wname);
375 free(wmode);
377 return file;
380 #else
382 #ifdef HAVE_DLFCN_H
384 void *LoadLib(const char *name)
386 const char *err;
387 void *handle;
389 dlerror();
390 handle = dlopen(name, RTLD_NOW);
391 if((err=dlerror()) != NULL)
392 handle = NULL;
393 return handle;
395 void CloseLib(void *handle)
396 { dlclose(handle); }
397 void *GetSymbol(void *handle, const char *name)
399 const char *err;
400 void *sym;
402 dlerror();
403 sym = dlsym(handle, name);
404 if((err=dlerror()) != NULL)
406 WARN("Failed to load %s: %s\n", name, err);
407 sym = NULL;
409 return sym;
412 #endif
413 #endif
416 void al_print(const char *type, const char *func, const char *fmt, ...)
418 va_list ap;
420 va_start(ap, fmt);
421 fprintf(LogFile, "AL lib: %s %s: ", type, func);
422 vfprintf(LogFile, fmt, ap);
423 va_end(ap);
425 fflush(LogFile);
428 #ifdef _WIN32
429 static inline int is_slash(int c)
430 { return (c == '\\' || c == '/'); }
432 FILE *OpenDataFile(const char *fname, const char *subdir)
434 static const int ids[2] = { CSIDL_APPDATA, CSIDL_COMMON_APPDATA };
435 WCHAR *wname=NULL, *wsubdir=NULL;
436 FILE *f;
437 int i;
439 /* If the path is absolute, open it directly. */
440 if(fname[0] != '\0' && fname[1] == ':' && is_slash(fname[2]))
442 if((f=al_fopen(fname, "rb")) != NULL)
444 TRACE("Opened %s\n", fname);
445 return f;
447 WARN("Could not open %s\n", fname);
448 return NULL;
451 /* If it's relative, try the current directory first before the data directories. */
452 if((f=al_fopen(fname, "rb")) != NULL)
454 TRACE("Opened %s\n", fname);
455 return f;
457 WARN("Could not open %s\n", fname);
459 wname = FromUTF8(fname);
460 wsubdir = FromUTF8(subdir);
461 if(!wname)
462 ERR("Failed to convert UTF-8 filename: \"%s\"\n", fname);
463 else if(!wsubdir)
464 ERR("Failed to convert UTF-8 subdir: \"%s\"\n", subdir);
465 else for(i = 0;i < 2;i++)
467 WCHAR buffer[PATH_MAX];
468 size_t len;
470 if(SHGetSpecialFolderPathW(NULL, buffer, ids[i], FALSE) == FALSE)
471 continue;
473 len = lstrlenW(buffer);
474 if(len > 0 && is_slash(buffer[len-1]))
475 buffer[--len] = '\0';
476 _snwprintf(buffer+len, PATH_MAX-len, L"/%ls/%ls", wsubdir, wname);
477 len = lstrlenW(buffer);
478 while(len > 0)
480 --len;
481 if(buffer[len] == '/')
482 buffer[len] = '\\';
485 if((f=_wfopen(buffer, L"rb")) != NULL)
487 TRACE("Opened %ls\n", buffer);
488 return f;
490 WARN("Could not open %ls\n", buffer);
492 free(wname);
493 free(wsubdir);
495 return NULL;
497 #else
498 FILE *OpenDataFile(const char *fname, const char *subdir)
500 char buffer[PATH_MAX] = "";
501 const char *str, *next;
502 FILE *f;
504 if(fname[0] == '/')
506 if((f=al_fopen(fname, "rb")) != NULL)
508 TRACE("Opened %s\n", fname);
509 return f;
511 WARN("Could not open %s\n", fname);
512 return NULL;
515 if((f=al_fopen(fname, "rb")) != NULL)
517 TRACE("Opened %s\n", fname);
518 return f;
520 WARN("Could not open %s\n", fname);
522 if((str=getenv("XDG_DATA_HOME")) != NULL && str[0] != '\0')
523 snprintf(buffer, sizeof(buffer), "%s/%s/%s", str, subdir, fname);
524 else if((str=getenv("HOME")) != NULL && str[0] != '\0')
525 snprintf(buffer, sizeof(buffer), "%s/.local/share/%s/%s", str, subdir, fname);
526 if(buffer[0])
528 if((f=al_fopen(buffer, "rb")) != NULL)
530 TRACE("Opened %s\n", buffer);
531 return f;
533 WARN("Could not open %s\n", buffer);
536 if((str=getenv("XDG_DATA_DIRS")) == NULL || str[0] == '\0')
537 str = "/usr/local/share/:/usr/share/";
539 next = str;
540 while((str=next) != NULL && str[0] != '\0')
542 size_t len;
543 next = strchr(str, ':');
545 if(!next)
546 len = strlen(str);
547 else
549 len = next - str;
550 next++;
553 if(len > sizeof(buffer)-1)
554 len = sizeof(buffer)-1;
555 strncpy(buffer, str, len);
556 buffer[len] = '\0';
557 snprintf(buffer+len, sizeof(buffer)-len, "/%s/%s", subdir, fname);
559 if((f=al_fopen(buffer, "rb")) != NULL)
561 TRACE("Opened %s\n", buffer);
562 return f;
564 WARN("Could not open %s\n", buffer);
567 return NULL;
569 #endif
572 void SetRTPriority(void)
574 ALboolean failed = AL_FALSE;
576 #ifdef _WIN32
577 if(RTPrioLevel > 0)
578 failed = !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
579 #elif defined(HAVE_PTHREAD_SETSCHEDPARAM) && !defined(__OpenBSD__)
580 if(RTPrioLevel > 0)
582 struct sched_param param;
583 /* Use the minimum real-time priority possible for now (on Linux this
584 * should be 1 for SCHED_RR) */
585 param.sched_priority = sched_get_priority_min(SCHED_RR);
586 failed = !!pthread_setschedparam(pthread_self(), SCHED_RR, &param);
588 #else
589 /* Real-time priority not available */
590 failed = (RTPrioLevel>0);
591 #endif
592 if(failed)
593 ERR("Failed to set priority level for thread\n");
597 ALboolean vector_reserve(void *ptr, size_t base_size, size_t obj_count, size_t obj_size, ALboolean exact)
599 vector_ *vecptr = ptr;
600 if((size_t)(*vecptr ? (*vecptr)->Capacity : 0) < obj_count)
602 ALsizei old_size = (*vecptr ? (*vecptr)->Size : 0);
603 void *temp;
605 /* Limit vector sizes to the greatest power-of-two value that an
606 * ALsizei can hold. */
607 if(obj_count > (INT_MAX>>1)+1)
608 return AL_FALSE;
610 /* Use the next power-of-2 size if we don't need to allocate the exact
611 * amount. This is preferred when regularly increasing the vector since
612 * it means fewer reallocations. Though it means it also wastes some
613 * memory. */
614 if(exact == AL_FALSE)
615 obj_count = NextPowerOf2((ALuint)obj_count);
617 /* Need to be explicit with the caller type's base size, because it
618 * could have extra padding before the start of the array (that is,
619 * sizeof(*vector_) may not equal base_size). */
620 temp = realloc(*vecptr, base_size + obj_size*obj_count);
621 if(temp == NULL) return AL_FALSE;
623 *vecptr = temp;
624 (*vecptr)->Capacity = (ALsizei)obj_count;
625 (*vecptr)->Size = old_size;
627 return AL_TRUE;
630 ALboolean vector_resize(void *ptr, size_t base_size, size_t obj_count, size_t obj_size)
632 vector_ *vecptr = ptr;
633 if(*vecptr || obj_count > 0)
635 if(!vector_reserve(vecptr, base_size, obj_count, obj_size, AL_TRUE))
636 return AL_FALSE;
637 (*vecptr)->Size = (ALsizei)obj_count;
639 return AL_TRUE;
642 ALboolean vector_insert(void *ptr, size_t base_size, size_t obj_size, void *ins_pos, const void *datstart, const void *datend)
644 vector_ *vecptr = ptr;
645 if(datstart != datend)
647 ptrdiff_t ins_elem = ((char*)ins_pos - ((char*)(*vecptr) + base_size)) / obj_size;
648 ptrdiff_t numins = ((const char*)datend - (const char*)datstart) / obj_size;
650 assert(numins > 0);
651 if(INT_MAX-VECTOR_SIZE(*vecptr) <= numins ||
652 !vector_reserve(vecptr, base_size, VECTOR_SIZE(*vecptr)+numins, obj_size, AL_TRUE))
653 return AL_FALSE;
655 /* NOTE: ins_pos may have been invalidated if *vecptr moved. Use ins_elem instead. */
656 if(ins_elem < (*vecptr)->Size)
658 memmove((char*)(*vecptr) + base_size + ((ins_elem+numins)*obj_size),
659 (char*)(*vecptr) + base_size + ((ins_elem )*obj_size),
660 ((*vecptr)->Size-ins_elem)*obj_size);
662 memcpy((char*)(*vecptr) + base_size + (ins_elem*obj_size),
663 datstart, numins*obj_size);
664 (*vecptr)->Size += (ALsizei)numins;
666 return AL_TRUE;
670 extern inline void al_string_deinit(al_string *str);
671 extern inline ALsizei al_string_length(const_al_string str);
672 extern inline ALboolean al_string_empty(const_al_string str);
673 extern inline const al_string_char_type *al_string_get_cstr(const_al_string str);
675 void al_string_clear(al_string *str)
677 /* Reserve one more character than the total size of the string. This is to
678 * ensure we have space to add a null terminator in the string data so it
679 * can be used as a C-style string. */
680 VECTOR_RESERVE(*str, 1);
681 VECTOR_RESIZE(*str, 0);
682 *VECTOR_ITER_END(*str) = 0;
685 static inline int al_string_compare(const al_string_char_type *str1, ALsizei str1len,
686 const al_string_char_type *str2, ALsizei str2len)
688 ALsizei complen = mini(str1len, str2len);
689 int ret = memcmp(str1, str2, complen);
690 if(ret == 0)
692 if(str1len > str2len) return 1;
693 if(str1len < str2len) return -1;
695 return ret;
697 int al_string_cmp(const_al_string str1, const_al_string str2)
699 return al_string_compare(&VECTOR_FRONT(str1), al_string_length(str1),
700 &VECTOR_FRONT(str2), al_string_length(str2));
702 int al_string_cmp_cstr(const_al_string str1, const al_string_char_type *str2)
704 return al_string_compare(&VECTOR_FRONT(str1), al_string_length(str1),
705 str2, (ALsizei)strlen(str2));
708 void al_string_copy(al_string *str, const_al_string from)
710 ALsizei len = VECTOR_SIZE(from);
711 VECTOR_RESERVE(*str, len+1);
712 VECTOR_RESIZE(*str, 0);
713 VECTOR_INSERT(*str, VECTOR_ITER_END(*str), VECTOR_ITER_BEGIN(from), VECTOR_ITER_BEGIN(from)+len);
714 *VECTOR_ITER_END(*str) = 0;
717 void al_string_copy_cstr(al_string *str, const al_string_char_type *from)
719 size_t len = strlen(from);
720 VECTOR_RESERVE(*str, len+1);
721 VECTOR_RESIZE(*str, 0);
722 VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, from+len);
723 *VECTOR_ITER_END(*str) = 0;
726 void al_string_append_char(al_string *str, const al_string_char_type c)
728 VECTOR_RESERVE(*str, al_string_length(*str)+2);
729 VECTOR_PUSH_BACK(*str, c);
730 *VECTOR_ITER_END(*str) = 0;
733 void al_string_append_cstr(al_string *str, const al_string_char_type *from)
735 size_t len = strlen(from);
736 if(len != 0)
738 VECTOR_RESERVE(*str, al_string_length(*str)+len+1);
739 VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, from+len);
740 *VECTOR_ITER_END(*str) = 0;
744 void al_string_append_range(al_string *str, const al_string_char_type *from, const al_string_char_type *to)
746 if(to != from)
748 VECTOR_RESERVE(*str, al_string_length(*str)+(to-from)+1);
749 VECTOR_INSERT(*str, VECTOR_ITER_END(*str), from, to);
750 *VECTOR_ITER_END(*str) = 0;
754 #ifdef _WIN32
755 void al_string_copy_wcstr(al_string *str, const wchar_t *from)
757 int len;
758 if((len=WideCharToMultiByte(CP_UTF8, 0, from, -1, NULL, 0, NULL, NULL)) > 0)
760 VECTOR_RESERVE(*str, len);
761 VECTOR_RESIZE(*str, len-1);
762 WideCharToMultiByte(CP_UTF8, 0, from, -1, &VECTOR_FRONT(*str), len, NULL, NULL);
763 *VECTOR_ITER_END(*str) = 0;
766 #endif