zenilib: zenilib/jni/external/sdl/src/stdlib/SDL_stdlib.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_stdlib.c
Go to the documentation of this file.
1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "SDL_config.h"
22
23 /* This file contains portable stdlib functions for SDL */
24
25 #include "SDL_stdinc.h"
26 #include "../libm/math_libm.h"
27
28
29 double
30 SDL_atan(double x)
31 {
32 #ifdef HAVE_ATAN
33 return atan(x);
34 #else
35 return SDL_uclibc_atan(x);
36 #endif /* HAVE_ATAN */
37 }
38
39 double
40 SDL_atan2(double x, double y)
41 {
42 #if defined(HAVE_ATAN2)
43 return atan2(x, y);
44 #else
45 return SDL_uclibc_atan2(x, y);
46 #endif /* HAVE_ATAN2 */
47 }
48
49 double
50 SDL_ceil(double x)
51 {
52 #ifdef HAVE_CEIL
53 return ceil(x);
54 #else
55 return (double)(int)((x)+0.5);
56 #endif /* HAVE_CEIL */
57 }
58
59 double
60 SDL_copysign(double x, double y)
61 {
62 #if defined(HAVE_COPYSIGN)
63 return copysign(x, y);
64 #else
65 return SDL_uclibc_copysign(x, y);
66 #endif /* HAVE_COPYSIGN */
67 }
68
69 double
70 SDL_cos(double x)
71 {
72 #if defined(HAVE_COS)
73 return cos(x);
74 #else
75 return SDL_uclibc_cos(x);
76 #endif /* HAVE_COS */
77 }
78
79 float
80 SDL_cosf(float x)
81 {
82 #ifdef HAVE_COSF
83 return cosf(x);
84 #else
85 return (float)SDL_cos((double)x);
86 #endif
87 }
88
89 double
90 SDL_fabs(double x)
91 {
92 #if defined(HAVE_FABS)
93 return fabs(x);
94 #else
95 return SDL_uclibc_fabs(x);
96 #endif /* HAVE_FABS */
97 }
98
99 double
100 SDL_floor(double x)
101 {
102 #if defined(HAVE_FLOOR)
103 return floor(x);
104 #else
105 return SDL_uclibc_floor(x);
106 #endif /* HAVE_FLOOR */
107 }
108
109 double
110 SDL_log(double x)
111 {
112 #if defined(HAVE_LOG)
113 return log(x);
114 #else
115 return SDL_uclibc_log(x);
116 #endif /* HAVE_LOG */
117 }
118
119 double
120 SDL_pow(double x, double y)
121 {
122 #if defined(HAVE_POW)
123 return pow(x, y);
124 #else
125 return SDL_uclibc_pow(x, y);
126 #endif /* HAVE_POW */
127 }
128
129 double
130 SDL_scalbn(double x, int n)
131 {
132 #if defined(HAVE_SCALBN)
133 return scalbn(x, n);
134 #else
135 return SDL_uclibc_scalbn(x, n);
136 #endif /* HAVE_SCALBN */
137 }
138
139 double
140 SDL_sin(double x)
141 {
142 #if defined(HAVE_SIN)
143 return sin(x);
144 #else
145 return SDL_uclibc_sin(x);
146 #endif /* HAVE_SIN */
147 }
148
149 float
150 SDL_sinf(float x)
151 {
152 #ifdef HAVE_SINF
153 return sinf(x);
154 #else
155 return (float)SDL_sin((double)x);
156 #endif /* HAVE_SINF */
157 }
158
159 double
160 SDL_sqrt(double x)
161 {
162 #if defined(HAVE_SQRT)
163 return sqrt(x);
164 #else
165 return SDL_uclibc_sqrt(x);
166 #endif
167 }
168
169 int SDL_abs(int x)
170 {
171 #ifdef HAVE_ABS
172 return abs(x);
173 #else
174 return ((x) < 0 ? -(x) : (x));
175 #endif
176 }
177
178 #ifdef HAVE_CTYPE_H
179 int SDL_isdigit(int x) { return isdigit(x); }
180 int SDL_isspace(int x) { return isspace(x); }
181 int SDL_toupper(int x) { return toupper(x); }
182 int SDL_tolower(int x) { return tolower(x); }
183 #else
184 int SDL_isdigit(int x) { return ((x) >= '0') && ((x) <= '9'); }
185 int SDL_isspace(int x) { return ((x) == ' ') || ((x) == '\t') || ((x) == '\r') || ((x) == '\n') || ((x) == '\f') || ((x) == '\v'); }
186 int SDL_toupper(int x) { return ((x) >= 'a') && ((x) <= 'z') ? ('A'+((x)-'a')) : (x); }
187 int SDL_tolower(int x) { return ((x) >= 'A') && ((x) <= 'Z') ? ('a'+((x)-'A')) : (x); }
188 #endif
189
190
191 #ifndef HAVE_LIBC
192 /* These are some C runtime intrinsics that need to be defined */
193
194 #if defined(_MSC_VER)
195
196 #ifndef __FLTUSED__
197 #define __FLTUSED__
198 __declspec(selectany) int _fltused = 1;
199 #endif
200
201 /* The optimizer on Visual Studio 2010/2012 generates memcpy() calls */
202 #if _MSC_VER >= 1600 && defined(_WIN64) && !defined(_DEBUG)
203 #include <intrin.h>
204
205 #pragma function(memcpy)
206 void * memcpy ( void * destination, const void * source, size_t num )
207 {
208 const Uint8 *src = (const Uint8 *)source;
209 Uint8 *dst = (Uint8 *)destination;
210 size_t i;
211
212 /* All WIN64 architectures have SSE, right? */
213 if (!((uintptr_t) src & 15) && !((uintptr_t) dst & 15)) {
214 __m128 values[4];
215 for (i = num / 64; i--;) {
216 _mm_prefetch(src, _MM_HINT_NTA);
217 values[0] = *(__m128 *) (src + 0);
218 values[1] = *(__m128 *) (src + 16);
219 values[2] = *(__m128 *) (src + 32);
220 values[3] = *(__m128 *) (src + 48);
221 _mm_stream_ps((float *) (dst + 0), values[0]);
222 _mm_stream_ps((float *) (dst + 16), values[1]);
223 _mm_stream_ps((float *) (dst + 32), values[2]);
224 _mm_stream_ps((float *) (dst + 48), values[3]);
225 src += 64;
226 dst += 64;
227 }
228 num &= 63;
229 }
230
231 while (num--) {
232 *dst++ = *src++;
233 }
234 return destination;
235 }
236 #endif /* _MSC_VER == 1600 && defined(_WIN64) && !defined(_DEBUG) */
237
238 #ifdef _M_IX86
239
240 void
241 __declspec(naked)
242 _chkstk()
243 {
244 }
245
246 /* Float to long */
247 void
248 __declspec(naked)
249 _ftol()
250 {
251 /* *INDENT-OFF* */
252 __asm {
253 push ebp
254 mov ebp,esp
255 sub esp,20h
256 and esp,0FFFFFFF0h
257 fld st(0)
258 fst dword ptr [esp+18h]
259 fistp qword ptr [esp+10h]
260 fild qword ptr [esp+10h]
261 mov edx,dword ptr [esp+18h]
262 mov eax,dword ptr [esp+10h]
263 test eax,eax
264 je integer_QnaN_or_zero
265 arg_is_not_integer_QnaN:
266 fsubp st(1),st
267 test edx,edx
268 jns positive
269 fstp dword ptr [esp]
270 mov ecx,dword ptr [esp]
271 xor ecx,80000000h
272 add ecx,7FFFFFFFh
273 adc eax,0
274 mov edx,dword ptr [esp+14h]
275 adc edx,0
276 jmp localexit
277 positive:
278 fstp dword ptr [esp]
279 mov ecx,dword ptr [esp]
280 add ecx,7FFFFFFFh
281 sbb eax,0
282 mov edx,dword ptr [esp+14h]
283 sbb edx,0
284 jmp localexit
285 integer_QnaN_or_zero:
286 mov edx,dword ptr [esp+14h]
287 test edx,7FFFFFFFh
288 jne arg_is_not_integer_QnaN
289 fstp dword ptr [esp+18h]
290 fstp dword ptr [esp+18h]
291 localexit:
292 leave
293 ret
294 }
295 /* *INDENT-ON* */
296 }
297
298 void
299 _ftol2_sse()
300 {
301 _ftol();
302 }
303
304 /* 64-bit math operators for 32-bit systems */
305 void
306 __declspec(naked)
307 _allmul()
308 {
309 /* *INDENT-OFF* */
310 __asm {
311 push ebp
312 mov ebp,esp
313 push edi
314 push esi
315 push ebx
316 sub esp,0Ch
317 mov eax,dword ptr [ebp+10h]
318 mov edi,dword ptr [ebp+8]
319 mov ebx,eax
320 mov esi,eax
321 sar esi,1Fh
322 mov eax,dword ptr [ebp+8]
323 mul ebx
324 imul edi,esi
325 mov ecx,edx
326 mov dword ptr [ebp-18h],eax
327 mov edx,dword ptr [ebp+0Ch]
328 add ecx,edi
329 imul ebx,edx
330 mov eax,dword ptr [ebp-18h]
331 lea ebx,[ebx+ecx]
332 mov dword ptr [ebp-14h],ebx
333 mov edx,dword ptr [ebp-14h]
334 add esp,0Ch
335 pop ebx
336 pop esi
337 pop edi
338 pop ebp
339 ret 10h
340 }
341 /* *INDENT-ON* */
342 }
343
344 void
345 __declspec(naked)
346 _alldiv()
347 {
348 /* *INDENT-OFF* */
349 __asm {
350 push edi
351 push esi
352 push ebx
353 xor edi,edi
354 mov eax,dword ptr [esp+14h]
355 or eax,eax
356 jge L1
357 inc edi
358 mov edx,dword ptr [esp+10h]
359 neg eax
360 neg edx
361 sbb eax,0
362 mov dword ptr [esp+14h],eax
363 mov dword ptr [esp+10h],edx
364 L1:
365 mov eax,dword ptr [esp+1Ch]
366 or eax,eax
367 jge L2
368 inc edi
369 mov edx,dword ptr [esp+18h]
370 neg eax
371 neg edx
372 sbb eax,0
373 mov dword ptr [esp+1Ch],eax
374 mov dword ptr [esp+18h],edx
375 L2:
376 or eax,eax
377 jne L3
378 mov ecx,dword ptr [esp+18h]
379 mov eax,dword ptr [esp+14h]
380 xor edx,edx
381 div ecx
382 mov ebx,eax
383 mov eax,dword ptr [esp+10h]
384 div ecx
385 mov edx,ebx
386 jmp L4
387 L3:
388 mov ebx,eax
389 mov ecx,dword ptr [esp+18h]
390 mov edx,dword ptr [esp+14h]
391 mov eax,dword ptr [esp+10h]
392 L5:
393 shr ebx,1
394 rcr ecx,1
395 shr edx,1
396 rcr eax,1
397 or ebx,ebx
398 jne L5
399 div ecx
400 mov esi,eax
401 mul dword ptr [esp+1Ch]
402 mov ecx,eax
403 mov eax,dword ptr [esp+18h]
404 mul esi
405 add edx,ecx
406 jb L6
407 cmp edx,dword ptr [esp+14h]
408 ja L6
409 jb L7
410 cmp eax,dword ptr [esp+10h]
411 jbe L7
412 L6:
413 dec esi
414 L7:
415 xor edx,edx
416 mov eax,esi
417 L4:
418 dec edi
419 jne L8
420 neg edx
421 neg eax
422 sbb edx,0
423 L8:
424 pop ebx
425 pop esi
426 pop edi
427 ret 10h
428 }
429 /* *INDENT-ON* */
430 }
431
432 void
433 __declspec(naked)
434 _aulldiv()
435 {
436 /* *INDENT-OFF* */
437 __asm {
438 push ebx
439 push esi
440 mov eax,dword ptr [esp+18h]
441 or eax,eax
442 jne L1
443 mov ecx,dword ptr [esp+14h]
444 mov eax,dword ptr [esp+10h]
445 xor edx,edx
446 div ecx
447 mov ebx,eax
448 mov eax,dword ptr [esp+0Ch]
449 div ecx
450 mov edx,ebx
451 jmp L2
452 L1:
453 mov ecx,eax
454 mov ebx,dword ptr [esp+14h]
455 mov edx,dword ptr [esp+10h]
456 mov eax,dword ptr [esp+0Ch]
457 L3:
458 shr ecx,1
459 rcr ebx,1
460 shr edx,1
461 rcr eax,1
462 or ecx,ecx
463 jne L3
464 div ebx
465 mov esi,eax
466 mul dword ptr [esp+18h]
467 mov ecx,eax
468 mov eax,dword ptr [esp+14h]
469 mul esi
470 add edx,ecx
471 jb L4
472 cmp edx,dword ptr [esp+10h]
473 ja L4
474 jb L5
475 cmp eax,dword ptr [esp+0Ch]
476 jbe L5
477 L4:
478 dec esi
479 L5:
480 xor edx,edx
481 mov eax,esi
482 L2:
483 pop esi
484 pop ebx
485 ret 10h
486 }
487 /* *INDENT-ON* */
488 }
489
490 void
491 __declspec(naked)
492 _allrem()
493 {
494 /* *INDENT-OFF* */
495 __asm {
496 push ebx
497 push edi
498 xor edi,edi
499 mov eax,dword ptr [esp+10h]
500 or eax,eax
501 jge L1
502 inc edi
503 mov edx,dword ptr [esp+0Ch]
504 neg eax
505 neg edx
506 sbb eax,0
507 mov dword ptr [esp+10h],eax
508 mov dword ptr [esp+0Ch],edx
509 L1:
510 mov eax,dword ptr [esp+18h]
511 or eax,eax
512 jge L2
513 mov edx,dword ptr [esp+14h]
514 neg eax
515 neg edx
516 sbb eax,0
517 mov dword ptr [esp+18h],eax
518 mov dword ptr [esp+14h],edx
519 L2:
520 or eax,eax
521 jne L3
522 mov ecx,dword ptr [esp+14h]
523 mov eax,dword ptr [esp+10h]
524 xor edx,edx
525 div ecx
526 mov eax,dword ptr [esp+0Ch]
527 div ecx
528 mov eax,edx
529 xor edx,edx
530 dec edi
531 jns L4
532 jmp L8
533 L3:
534 mov ebx,eax
535 mov ecx,dword ptr [esp+14h]
536 mov edx,dword ptr [esp+10h]
537 mov eax,dword ptr [esp+0Ch]
538 L5:
539 shr ebx,1
540 rcr ecx,1
541 shr edx,1
542 rcr eax,1
543 or ebx,ebx
544 jne L5
545 div ecx
546 mov ecx,eax
547 mul dword ptr [esp+18h]
548 xchg eax,ecx
549 mul dword ptr [esp+14h]
550 add edx,ecx
551 jb L6
552 cmp edx,dword ptr [esp+10h]
553 ja L6
554 jb L7
555 cmp eax,dword ptr [esp+0Ch]
556 jbe L7
557 L6:
558 sub eax,dword ptr [esp+14h]
559 sbb edx,dword ptr [esp+18h]
560 L7:
561 sub eax,dword ptr [esp+0Ch]
562 sbb edx,dword ptr [esp+10h]
563 dec edi
564 jns L8
565 L4:
566 neg edx
567 neg eax
568 sbb edx,0
569 L8:
570 pop edi
571 pop ebx
572 ret 10h
573 }
574 /* *INDENT-ON* */
575 }
576
577 void
578 __declspec(naked)
579 _aullrem()
580 {
581 /* *INDENT-OFF* */
582 __asm {
583 push ebx
584 mov eax,dword ptr [esp+14h]
585 or eax,eax
586 jne L1
587 mov ecx,dword ptr [esp+10h]
588 mov eax,dword ptr [esp+0Ch]
589 xor edx,edx
590 div ecx
591 mov eax,dword ptr [esp+8]
592 div ecx
593 mov eax,edx
594 xor edx,edx
595 jmp L2
596 L1:
597 mov ecx,eax
598 mov ebx,dword ptr [esp+10h]
599 mov edx,dword ptr [esp+0Ch]
600 mov eax,dword ptr [esp+8]
601 L3:
602 shr ecx,1
603 rcr ebx,1
604 shr edx,1
605 rcr eax,1
606 or ecx,ecx
607 jne L3
608 div ebx
609 mov ecx,eax
610 mul dword ptr [esp+14h]
611 xchg eax,ecx
612 mul dword ptr [esp+10h]
613 add edx,ecx
614 jb L4
615 cmp edx,dword ptr [esp+0Ch]
616 ja L4
617 jb L5
618 cmp eax,dword ptr [esp+8]
619 jbe L5
620 L4:
621 sub eax,dword ptr [esp+10h]
622 sbb edx,dword ptr [esp+14h]
623 L5:
624 sub eax,dword ptr [esp+8]
625 sbb edx,dword ptr [esp+0Ch]
626 neg edx
627 neg eax
628 sbb edx,0
629 L2:
630 pop ebx
631 ret 10h
632 }
633 /* *INDENT-ON* */
634 }
635
636 void
637 __declspec(naked)
638 _alldvrm()
639 {
640 /* *INDENT-OFF* */
641 __asm {
642 push edi
643 push esi
644 push ebp
645 xor edi,edi
646 xor ebp,ebp
647 mov eax,dword ptr [esp+14h]
648 or eax,eax
649 jge L1
650 inc edi
651 inc ebp
652 mov edx,dword ptr [esp+10h]
653 neg eax
654 neg edx
655 sbb eax,0
656 mov dword ptr [esp+14h],eax
657 mov dword ptr [esp+10h],edx
658 L1:
659 mov eax,dword ptr [esp+1Ch]
660 or eax,eax
661 jge L2
662 inc edi
663 mov edx,dword ptr [esp+18h]
664 neg eax
665 neg edx
666 sbb eax,0
667 mov dword ptr [esp+1Ch],eax
668 mov dword ptr [esp+18h],edx
669 L2:
670 or eax,eax
671 jne L3
672 mov ecx,dword ptr [esp+18h]
673 mov eax,dword ptr [esp+14h]
674 xor edx,edx
675 div ecx
676 mov ebx,eax
677 mov eax,dword ptr [esp+10h]
678 div ecx
679 mov esi,eax
680 mov eax,ebx
681 mul dword ptr [esp+18h]
682 mov ecx,eax
683 mov eax,esi
684 mul dword ptr [esp+18h]
685 add edx,ecx
686 jmp L4
687 L3:
688 mov ebx,eax
689 mov ecx,dword ptr [esp+18h]
690 mov edx,dword ptr [esp+14h]
691 mov eax,dword ptr [esp+10h]
692 L5:
693 shr ebx,1
694 rcr ecx,1
695 shr edx,1
696 rcr eax,1
697 or ebx,ebx
698 jne L5
699 div ecx
700 mov esi,eax
701 mul dword ptr [esp+1Ch]
702 mov ecx,eax
703 mov eax,dword ptr [esp+18h]
704 mul esi
705 add edx,ecx
706 jb L6
707 cmp edx,dword ptr [esp+14h]
708 ja L6
709 jb L7
710 cmp eax,dword ptr [esp+10h]
711 jbe L7
712 L6:
713 dec esi
714 sub eax,dword ptr [esp+18h]
715 sbb edx,dword ptr [esp+1Ch]
716 L7:
717 xor ebx,ebx
718 L4:
719 sub eax,dword ptr [esp+10h]
720 sbb edx,dword ptr [esp+14h]
721 dec ebp
722 jns L9
723 neg edx
724 neg eax
725 sbb edx,0
726 L9:
727 mov ecx,edx
728 mov edx,ebx
729 mov ebx,ecx
730 mov ecx,eax
731 mov eax,esi
732 dec edi
733 jne L8
734 neg edx
735 neg eax
736 sbb edx,0
737 L8:
738 pop ebp
739 pop esi
740 pop edi
741 ret 10h
742 }
743 /* *INDENT-ON* */
744 }
745
746 void
747 __declspec(naked)
748 _aulldvrm()
749 {
750 /* *INDENT-OFF* */
751 __asm {
752 push esi
753 mov eax,dword ptr [esp+14h]
754 or eax,eax
755 jne L1
756 mov ecx,dword ptr [esp+10h]
757 mov eax,dword ptr [esp+0Ch]
758 xor edx,edx
759 div ecx
760 mov ebx,eax
761 mov eax,dword ptr [esp+8]
762 div ecx
763 mov esi,eax
764 mov eax,ebx
765 mul dword ptr [esp+10h]
766 mov ecx,eax
767 mov eax,esi
768 mul dword ptr [esp+10h]
769 add edx,ecx
770 jmp L2
771 L1:
772 mov ecx,eax
773 mov ebx,dword ptr [esp+10h]
774 mov edx,dword ptr [esp+0Ch]
775 mov eax,dword ptr [esp+8]
776 L3:
777 shr ecx,1
778 rcr ebx,1
779 shr edx,1
780 rcr eax,1
781 or ecx,ecx
782 jne L3
783 div ebx
784 mov esi,eax
785 mul dword ptr [esp+14h]
786 mov ecx,eax
787 mov eax,dword ptr [esp+10h]
788 mul esi
789 add edx,ecx
790 jb L4
791 cmp edx,dword ptr [esp+0Ch]
792 ja L4
793 jb L5
794 cmp eax,dword ptr [esp+8]
795 jbe L5
796 L4:
797 dec esi
798 sub eax,dword ptr [esp+10h]
799 sbb edx,dword ptr [esp+14h]
800 L5:
801 xor ebx,ebx
802 L2:
803 sub eax,dword ptr [esp+8]
804 sbb edx,dword ptr [esp+0Ch]
805 neg edx
806 neg eax
807 sbb edx,0
808 mov ecx,edx
809 mov edx,ebx
810 mov ebx,ecx
811 mov ecx,eax
812 mov eax,esi
813 pop esi
814 ret 10h
815 }
816 /* *INDENT-ON* */
817 }
818
819 void
820 __declspec(naked)
821 _allshl()
822 {
823 /* *INDENT-OFF* */
824 __asm {
825 cmp cl,40h
826 jae RETZERO
827 cmp cl,20h
828 jae MORE32
829 shld edx,eax,cl
830 shl eax,cl
831 ret
832 MORE32:
833 mov edx,eax
834 xor eax,eax
835 and cl,1Fh
836 shl edx,cl
837 ret
838 RETZERO:
839 xor eax,eax
840 xor edx,edx
841 ret
842 }
843 /* *INDENT-ON* */
844 }
845
846 void
847 __declspec(naked)
848 _allshr()
849 {
850 /* *INDENT-OFF* */
851 __asm {
852 cmp cl,40h
853 jae RETZERO
854 cmp cl,20h
855 jae MORE32
856 shrd eax,edx,cl
857 sar edx,cl
858 ret
859 MORE32:
860 mov eax,edx
861 xor edx,edx
862 and cl,1Fh
863 sar eax,cl
864 ret
865 RETZERO:
866 xor eax,eax
867 xor edx,edx
868 ret
869 }
870 /* *INDENT-ON* */
871 }
872
873 void
874 __declspec(naked)
875 _aullshr()
876 {
877 /* *INDENT-OFF* */
878 __asm {
879 cmp cl,40h
880 jae RETZERO
881 cmp cl,20h
882 jae MORE32
883 shrd eax,edx,cl
884 shr edx,cl
885 ret
886 MORE32:
887 mov eax,edx
888 xor edx,edx
889 and cl,1Fh
890 shr eax,cl
891 ret
892 RETZERO:
893 xor eax,eax
894 xor edx,edx
895 ret
896 }
897 /* *INDENT-ON* */
898 }
899
900 #endif /* _M_IX86 */
901
902 #endif /* MSC_VER */
903
904 #endif /* !HAVE_LIBC */
905
906 /* vi: set ts=4 sw=4 expandtab: */
SDL_isspace
DECLSPEC int SDLCALL SDL_isspace(int x)
Definition: SDL_stdlib.c:185
SDL_cos
DECLSPEC double SDLCALL SDL_cos(double x)
Definition: SDL_stdlib.c:70
SDL_cosf
DECLSPEC float SDLCALL SDL_cosf(float x)
Definition: SDL_stdlib.c:80
SDL_uclibc_log
double SDL_uclibc_log(double x)
L5
static double L5
Definition: e_pow.c:85
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glew.h:7294
SDL_fabs
DECLSPEC double SDLCALL SDL_fabs(double x)
Definition: SDL_stdlib.c:90
SDL_pow
DECLSPEC double SDLCALL SDL_pow(double x, double y)
Definition: SDL_stdlib.c:120
n
GLclampd n
Definition: glew.h:7287
SDL_copysign
DECLSPEC double SDLCALL SDL_copysign(double x, double y)
Definition: SDL_stdlib.c:60
x
EGLSurface EGLint x
Definition: eglext.h:293
SDL_uclibc_sin
double SDL_uclibc_sin(double x)
SDL_uclibc_atan2
double SDL_uclibc_atan2(double y, double x)
SDL_tolower
DECLSPEC int SDLCALL SDL_tolower(int x)
Definition: SDL_stdlib.c:187
SDL_uclibc_copysign
double SDL_uclibc_copysign(double x, double y)
SDL_uclibc_pow
double SDL_uclibc_pow(double x, double y)
SDL_uclibc_floor
double SDL_uclibc_floor(double x)
SDL_abs
DECLSPEC int SDLCALL SDL_abs(int x)
Definition: SDL_stdlib.c:169
SDL_config.h
ret
ret
Definition: glew_str_glx.c:2
SDL_sin
DECLSPEC double SDLCALL SDL_sin(double x)
Definition: SDL_stdlib.c:140
L6
static double L6
Definition: e_pow.c:86
SDL_uclibc_fabs
double SDL_uclibc_fabs(double x)
SDL_uclibc_sqrt
double SDL_uclibc_sqrt(double x)
L2
static double L2
Definition: e_pow.c:82
dst
GLenum GLenum dst
Definition: glew.h:2396
int
int
Definition: SDL_systhread.c:37
pop
#define pop
Definition: SDL_qsort.c:125
L4
static double L4
Definition: e_pow.c:84
SDL_atan
DECLSPEC double SDLCALL SDL_atan(double x)
Definition: SDL_stdlib.c:30
SDL_scalbn
DECLSPEC double SDLCALL SDL_scalbn(double x, int n)
Definition: SDL_stdlib.c:130
uintptr_t
unsigned int uintptr_t
Definition: SDL_config_windows.h:69
floor
double floor(double x)
Definition: s_floor.c:40
SDL_floor
DECLSPEC double SDLCALL SDL_floor(double x)
Definition: SDL_stdlib.c:100
L1
static double L1
Definition: e_pow.c:81
SDL_sinf
DECLSPEC float SDLCALL SDL_sinf(float x)
Definition: SDL_stdlib.c:150
num
GLuint num
Definition: glew.h:2631
sin
double sin(double x)
Definition: s_sin.c:56
y
EGLSurface EGLint EGLint y
Definition: eglext.h:293
copysign
double copysign(double x, double y)
Definition: s_copysign.c:31
SDL_log
DECLSPEC double SDLCALL SDL_log(double x)
Definition: SDL_stdlib.c:110
memcpy
#define memcpy
Definition: SDL_malloc.c:634
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
SDL_toupper
DECLSPEC int SDLCALL SDL_toupper(int x)
Definition: SDL_stdlib.c:186
SDL_uclibc_cos
double SDL_uclibc_cos(double x)
SDL_ceil
DECLSPEC double SDLCALL SDL_ceil(double x)
Definition: SDL_stdlib.c:50
SDL_uclibc_atan
double SDL_uclibc_atan(double x)
SDL_sqrt
DECLSPEC double SDLCALL SDL_sqrt(double x)
Definition: SDL_stdlib.c:160
L3
static double L3
Definition: e_pow.c:83
scalbn
double scalbn(double x, int n)
Definition: s_scalbn.c:42
atan
double atan(double x)
Definition: s_atan.c:67
src
GLenum src
Definition: glew.h:2396
SDL_atan2
DECLSPEC double SDLCALL SDL_atan2(double x, double y)
Definition: SDL_stdlib.c:40
i
int i
Definition: pngrutil.c:1377
cos
double cos(double x)
Definition: s_cos.c:56
source
GLsizei GLsizei GLchar * source
Definition: gl2ext.h:994
fabs
double fabs(double x)
Definition: s_fabs.c:29
SDL_isdigit
DECLSPEC int SDLCALL SDL_isdigit(int x)
Definition: SDL_stdlib.c:184
SDL_uclibc_scalbn
double SDL_uclibc_scalbn(double x, int n)
values
GLint GLsizei const GLuint64 * values
Definition: glew.h:3473