// Code generated by 'ccgo -D__environ=environ -export-externs X -hide __syscall0,__syscall1,__syscall2,__syscall3,__syscall4,__syscall5,__syscall6 -nostdinc -nostdlib -o ../musl_windows_386.go -pkgname libc -static-locals-prefix _s -Iarch/i386 -Iarch/generic -Iobj/src/internal -Isrc/include -Isrc/internal -Iobj/include -Iinclude copyright.c src/ctype/isalnum.c src/ctype/isalpha.c src/ctype/isdigit.c src/ctype/islower.c src/ctype/isprint.c src/ctype/isspace.c src/ctype/isxdigit.c src/env/putenv.c src/env/setenv.c src/env/unsetenv.c src/multibyte/wcrtomb.c src/multibyte/wcsrtombs.c src/multibyte/wcstombs.c src/string/strchrnul.c src/string/strdup.c', DO NOT EDIT. package libc import ( "math" "reflect" "sync/atomic" "unsafe" ) var _ = math.Pi var _ reflect.Kind var _ atomic.Value var _ unsafe.Pointer // musl as a whole is licensed under the following standard MIT license: // // ---------------------------------------------------------------------- // Copyright © 2005-2020 Rich Felker, et al. // // Permission is hereby granted, free of charge, to any person obtaining // a copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to // permit persons to whom the Software is furnished to do so, subject to // the following conditions: // // The above copyright notice and this permission notice shall be // included in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // ---------------------------------------------------------------------- // // Authors/contributors include: // // A. Wilcox // Ada Worcester // Alex Dowad // Alex Suykov // Alexander Monakov // Andre McCurdy // Andrew Kelley // Anthony G. Basile // Aric Belsito // Arvid Picciani // Bartosz Brachaczek // Benjamin Peterson // Bobby Bingham // Boris Brezillon // Brent Cook // Chris Spiegel // Clément Vasseur // Daniel Micay // Daniel Sabogal // Daurnimator // David Carlier // David Edelsohn // Denys Vlasenko // Dmitry Ivanov // Dmitry V. Levin // Drew DeVault // Emil Renner Berthing // Fangrui Song // Felix Fietkau // Felix Janda // Gianluca Anzolin // Hauke Mehrtens // He X // Hiltjo Posthuma // Isaac Dunham // Jaydeep Patil // Jens Gustedt // Jeremy Huntwork // Jo-Philipp Wich // Joakim Sindholt // John Spencer // Julien Ramseier // Justin Cormack // Kaarle Ritvanen // Khem Raj // Kylie McClain // Leah Neukirchen // Luca Barbato // Luka Perkov // M Farkas-Dyck (Strake) // Mahesh Bodapati // Markus Wichmann // Masanori Ogino // Michael Clark // Michael Forney // Mikhail Kremnyov // Natanael Copa // Nicholas J. Kain // orc // Pascal Cuoq // Patrick Oppenlander // Petr Hosek // Petr Skocik // Pierre Carrier // Reini Urban // Rich Felker // Richard Pennington // Ryan Fairfax // Samuel Holland // Segev Finer // Shiz // sin // Solar Designer // Stefan Kristiansson // Stefan O'Rear // Szabolcs Nagy // Timo Teräs // Trutz Behn // Valentin Ochs // Will Dietz // William Haddon // William Pitcock // // Portions of this software are derived from third-party works licensed // under terms compatible with the above MIT license: // // The TRE regular expression implementation (src/regex/reg* and // src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed // under a 2-clause BSD license (license text in the source files). The // included version has been heavily modified by Rich Felker in 2012, in // the interests of size, simplicity, and namespace cleanliness. // // Much of the math library code (src/math/* and src/complex/*) is // Copyright © 1993,2004 Sun Microsystems or // Copyright © 2003-2011 David Schultz or // Copyright © 2003-2009 Steven G. Kargl or // Copyright © 2003-2009 Bruce D. Evans or // Copyright © 2008 Stephen L. Moshier or // Copyright © 2017-2018 Arm Limited // and labelled as such in comments in the individual source files. All // have been licensed under extremely permissive terms. // // The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008 // The Android Open Source Project and is licensed under a two-clause BSD // license. It was taken from Bionic libc, used on Android. // // The AArch64 memcpy and memset code (src/string/aarch64/*) are // Copyright © 1999-2019, Arm Limited. // // The implementation of DES for crypt (src/crypt/crypt_des.c) is // Copyright © 1994 David Burren. It is licensed under a BSD license. // // The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was // originally written by Solar Designer and placed into the public // domain. The code also comes with a fallback permissive license for use // in jurisdictions that may not recognize the public domain. // // The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011 // Valentin Ochs and is licensed under an MIT-style license. // // The x86_64 port was written by Nicholas J. Kain and is licensed under // the standard MIT terms. // // The mips and microblaze ports were originally written by Richard // Pennington for use in the ellcc project. The original code was adapted // by Rich Felker for build system and code conventions during upstream // integration. It is licensed under the standard MIT terms. // // The mips64 port was contributed by Imagination Technologies and is // licensed under the standard MIT terms. // // The powerpc port was also originally written by Richard Pennington, // and later supplemented and integrated by John Spencer. It is licensed // under the standard MIT terms. // // All other files which have no copyright comments are original works // produced specifically for use as part of this library, written either // by Rich Felker, the main author of the library, or by one or more // contibutors listed above. Details on authorship of individual files // can be found in the git version control history of the project. The // omission of copyright and license comments in each file is in the // interest of source tree size. // // In addition, permission is hereby granted for all public header files // (include/* and arch/*/bits/*) and crt files intended to be linked into // applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit // the copyright notice and permission notice otherwise required by the // license, and to use these files without any requirement of // attribution. These files include substantial contributions from: // // Bobby Bingham // John Spencer // Nicholas J. Kain // Rich Felker // Richard Pennington // Stefan Kristiansson // Szabolcs Nagy // // all of whom have explicitly granted such permission. // // This file previously contained text expressing a belief that most of // the files covered by the above exception were sufficiently trivial not // to be subject to copyright, resulting in confusion over whether it // negated the permissions granted in the license. In the spirit of // permissive licensing, and of not having licensing issues being an // obstacle to adoption, that text has been removed. const ( /* copyright.c:194:1: */ __musl__copyright__ = 0 ) const ( /* pthread_impl.h:58:1: */ DT_EXITING = 0 DT_JOINABLE = 1 DT_DETACHED = 2 ) type ptrdiff_t = int32 /* <builtin>:3:26 */ type size_t = uint32 /* <builtin>:9:23 */ type wchar_t = uint16 /* <builtin>:15:24 */ type va_list = uintptr /* <builtin>:50:27 */ type __locale_struct = struct{ cat [6]uintptr } /* alltypes.h:366:9 */ type locale_t = uintptr /* alltypes.h:366:32 */ func Xisalnum(tls *TLS, c int32) int32 { /* isalnum.c:3:5: */ return (Bool32((func() int32 { if 0 != 0 { return Xisalpha(tls, c) } return (Bool32((((uint32(c)) | uint32(32)) - uint32('a')) < uint32(26))) }() != 0) || (func() int32 { if 0 != 0 { return Xisdigit(tls, c) } return (Bool32(((uint32(c)) - uint32('0')) < uint32(10))) }() != 0))) } func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 { /* isalnum.c:8:5: */ return Xisalnum(tls, c) } func Xisalpha(tls *TLS, c int32) int32 { /* isalpha.c:4:5: */ return (Bool32(((uint32(c) | uint32(32)) - uint32('a')) < uint32(26))) } func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 { /* isalpha.c:9:5: */ return Xisalpha(tls, c) } func Xisdigit(tls *TLS, c int32) int32 { /* isdigit.c:4:5: */ return (Bool32((uint32(c) - uint32('0')) < uint32(10))) } func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isdigit.c:9:5: */ return Xisdigit(tls, c) } func Xislower(tls *TLS, c int32) int32 { /* islower.c:4:5: */ return (Bool32((uint32(c) - uint32('a')) < uint32(26))) } func X__islower_l(tls *TLS, c int32, l locale_t) int32 { /* islower.c:9:5: */ return Xislower(tls, c) } func Xisprint(tls *TLS, c int32) int32 { /* isprint.c:4:5: */ return (Bool32((uint32(c) - uint32(0x20)) < uint32(0x5f))) } func X__isprint_l(tls *TLS, c int32, l locale_t) int32 { /* isprint.c:9:5: */ return Xisprint(tls, c) } func Xisspace(tls *TLS, c int32) int32 { /* isspace.c:4:5: */ return (Bool32((c == ' ') || ((uint32(c) - uint32('\t')) < uint32(5)))) } func X__isspace_l(tls *TLS, c int32, l locale_t) int32 { /* isspace.c:9:5: */ return Xisspace(tls, c) } func Xisxdigit(tls *TLS, c int32) int32 { /* isxdigit.c:3:5: */ return (Bool32((func() int32 { if 0 != 0 { return Xisdigit(tls, c) } return (Bool32(((uint32(c)) - uint32('0')) < uint32(10))) }() != 0) || (((uint32(c) | uint32(32)) - uint32('a')) < uint32(6)))) } func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isxdigit.c:8:5: */ return Xisxdigit(tls, c) } type div_t = struct { quot int32 rem int32 } /* stdlib.h:62:35 */ type ldiv_t = struct { quot int32 rem int32 } /* stdlib.h:63:36 */ type lldiv_t = struct { quot int64 rem int64 } /* stdlib.h:64:41 */ type ssize_t = int32 /* alltypes.h:88:15 */ type intptr_t = int32 /* alltypes.h:93:15 */ type off_t = int64 /* alltypes.h:185:16 */ type pid_t = int32 /* alltypes.h:258:13 */ type uid_t = uint32 /* alltypes.h:268:18 */ type gid_t = uint32 /* alltypes.h:273:18 */ type useconds_t = uint32 /* alltypes.h:283:18 */ func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32 { /* putenv.c:8:5: */ var i size_t var newenv uintptr var tmp uintptr //TODO for (char **e = __environ; *e; e++, i++) var e uintptr i = size_t(0) if !(Environ() != 0) { goto __1 } //TODO for (char **e = __environ; *e; e++, i++) e = Environ() __2: if !(*(*uintptr)(unsafe.Pointer(e)) != 0) { goto __4 } if !(!(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), (l+size_t(1))) != 0)) { goto __5 } tmp = *(*uintptr)(unsafe.Pointer(e)) *(*uintptr)(unsafe.Pointer(e)) = s X__env_rm_add(tls, tmp, r) return 0 __5: ; goto __3 __3: e += 4 i++ goto __2 goto __4 __4: ; __1: ; if !(Environ() == _soldenv) { goto __6 } newenv = Xrealloc(tls, _soldenv, (uint32(unsafe.Sizeof(uintptr(0))) * (i + size_t(2)))) if !(!(newenv != 0)) { goto __8 } goto oom __8: ; goto __7 __6: newenv = Xmalloc(tls, (uint32(unsafe.Sizeof(uintptr(0))) * (i + size_t(2)))) if !(!(newenv != 0)) { goto __9 } goto oom __9: ; if !(i != 0) { goto __10 } Xmemcpy(tls, newenv, Environ(), (uint32(unsafe.Sizeof(uintptr(0))) * i)) __10: ; Xfree(tls, _soldenv) __7: ; *(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*4)) = s *(*uintptr)(unsafe.Pointer(newenv + uintptr((i+size_t(1)))*4)) = uintptr(0) *(*uintptr)(unsafe.Pointer(EnvironP())) = AssignPtrUintptr(uintptr(unsafe.Pointer(&_soldenv)), newenv) if !(r != 0) { goto __11 } X__env_rm_add(tls, uintptr(0), r) __11: ; return 0 oom: Xfree(tls, r) return -1 } var _soldenv uintptr /* putenv.c:22:14: */ func Xputenv(tls *TLS, s uintptr) int32 { /* putenv.c:43:5: */ var l size_t = (size_t((int32(X__strchrnul(tls, s, '=')) - int32(s)) / 1)) if !(l != 0) || !(int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) != 0) { return Xunsetenv(tls, s) } return X__putenv(tls, s, l, uintptr(0)) } func X__env_rm_add(tls *TLS, old uintptr, new uintptr) { /* setenv.c:5:6: */ //TODO for (size_t i=0; i < env_alloced_n; i++) var i size_t = size_t(0) for ; i < _senv_alloced_n; i++ { if *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) == old { *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) = new Xfree(tls, old) return } else if !(int32(*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4))) != 0) && (new != 0) { *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) = new new = uintptr(0) } } if !(new != 0) { return } var t uintptr = Xrealloc(tls, _senv_alloced, (uint32(unsafe.Sizeof(uintptr(0))) * (_senv_alloced_n + size_t(1)))) if !(t != 0) { return } *(*uintptr)(unsafe.Pointer((AssignPtrUintptr(uintptr(unsafe.Pointer(&_senv_alloced)), t)) + uintptr(PostIncUint32(&_senv_alloced_n, 1))*4)) = new } var _senv_alloced uintptr /* setenv.c:7:14: */ var _senv_alloced_n size_t /* setenv.c:8:16: */ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32 { /* setenv.c:26:5: */ var s uintptr var l1 size_t var l2 size_t if (!(var1 != 0) || !(int32(AssignUint32(&l1, (size_t((int32(X__strchrnul(tls, var1, '='))-int32(var1))/1)))) != 0)) || (*(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0) { (*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22 return -1 } if !(overwrite != 0) && (Xgetenv(tls, var1) != 0) { return 0 } l2 = Xstrlen(tls, value) s = Xmalloc(tls, ((l1 + l2) + size_t(2))) if !(s != 0) { return -1 } Xmemcpy(tls, s, var1, l1) *(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=') Xmemcpy(tls, ((s + uintptr(l1)) + uintptr(1)), value, (l2 + size_t(1))) return X__putenv(tls, s, l1, s) } func Xunsetenv(tls *TLS, name uintptr) int32 { /* unsetenv.c:9:5: */ var l size_t = (size_t((int32(X__strchrnul(tls, name, '=')) - int32(name)) / 1)) if !(l != 0) || (*(*int8)(unsafe.Pointer(name + uintptr(l))) != 0) { (*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22 return -1 } if Environ() != 0 { var e uintptr = Environ() var eo uintptr = e for ; *(*uintptr)(unsafe.Pointer(e)) != 0; e += 4 { //TODO if (!strncmp(name, *e, l) && l[*e] == '=') if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && (int32(*(*int8)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(e))) + uintptr(l)))) == '=') { X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0)) } else if eo != e { *(*uintptr)(unsafe.Pointer(PostIncUintptr(&eo, 4))) = *(*uintptr)(unsafe.Pointer(e)) } else { eo += 4 } } if eo != e { *(*uintptr)(unsafe.Pointer(eo)) = uintptr(0) } } return 0 } type wint_t = uint32 /* alltypes.h:221:18 */ type wctype_t = uint32 /* alltypes.h:226:23 */ type __mbstate_t = struct { __opaque1 uint32 __opaque2 uint32 } /* alltypes.h:360:9 */ type mbstate_t = __mbstate_t /* alltypes.h:360:63 */ type tm = struct { tm_sec int32 tm_min int32 tm_hour int32 tm_mday int32 tm_mon int32 tm_year int32 tm_wday int32 tm_yday int32 tm_isdst int32 tm_gmtoff int32 tm_zone uintptr } /* wchar.h:138:1 */ type uintptr_t = uint32 /* alltypes.h:78:24 */ type int8_t = int8 /* alltypes.h:119:25 */ type int16_t = int16 /* alltypes.h:124:25 */ type int32_t = int32 /* alltypes.h:129:25 */ type int64_t = int64 /* alltypes.h:134:25 */ type intmax_t = int64 /* alltypes.h:139:25 */ type uint8_t = uint8 /* alltypes.h:144:25 */ type uint16_t = uint16 /* alltypes.h:149:25 */ type uint32_t = uint32 /* alltypes.h:154:25 */ type uint64_t = uint64 /* alltypes.h:159:25 */ type uintmax_t = uint64 /* alltypes.h:169:25 */ type int_fast8_t = int8_t /* stdint.h:22:16 */ type int_fast64_t = int64_t /* stdint.h:23:17 */ type int_least8_t = int8_t /* stdint.h:25:17 */ type int_least16_t = int16_t /* stdint.h:26:17 */ type int_least32_t = int32_t /* stdint.h:27:17 */ type int_least64_t = int64_t /* stdint.h:28:17 */ type uint_fast8_t = uint8_t /* stdint.h:30:17 */ type uint_fast64_t = uint64_t /* stdint.h:31:18 */ type uint_least8_t = uint8_t /* stdint.h:33:18 */ type uint_least16_t = uint16_t /* stdint.h:34:18 */ type uint_least32_t = uint32_t /* stdint.h:35:18 */ type uint_least64_t = uint64_t /* stdint.h:36:18 */ type int_fast16_t = int32_t /* stdint.h:1:17 */ type int_fast32_t = int32_t /* stdint.h:2:17 */ type uint_fast16_t = uint32_t /* stdint.h:3:18 */ type uint_fast32_t = uint32_t /* stdint.h:4:18 */ // Upper 6 state bits are a negative integer offset to bound-check next byte // equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f // Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear. // Arbitrary encoding for representing code units instead of characters. // Get inline definition of MB_CUR_MAX. type lconv = struct { decimal_point uintptr thousands_sep uintptr grouping uintptr int_curr_symbol uintptr currency_symbol uintptr mon_decimal_point uintptr mon_thousands_sep uintptr mon_grouping uintptr positive_sign uintptr negative_sign uintptr int_frac_digits int8 frac_digits int8 p_cs_precedes int8 p_sep_by_space int8 n_cs_precedes int8 n_sep_by_space int8 p_sign_posn int8 n_sign_posn int8 int_p_cs_precedes int8 int_p_sep_by_space int8 int_n_cs_precedes int8 int_n_sep_by_space int8 int_p_sign_posn int8 int_n_sign_posn int8 _ [2]byte } /* locale.h:24:1 */ type _G_fpos64_t = struct { _ [0]uint64 __opaque [16]int8 } /* stdio.h:54:9 */ type fpos_t = _G_fpos64_t /* stdio.h:58:3 */ // Support signed or unsigned plain-char // Implementation choices... // Arbitrary numbers... // POSIX/SUS requirements follow. These numbers come directly // from SUS and have nothing to do with the host system. type __locale_map = struct { __map uintptr map_size size_t name [24]int8 next uintptr } /* alltypes.h:366:9 */ type tls_module = struct { next uintptr image uintptr len size_t size size_t align size_t offset size_t } /* libc.h:14:1 */ type __libc = struct { can_do_threads int8 threaded int8 secure int8 need_locks int8 threads_minus_1 int32 auxv uintptr tls_head uintptr tls_size size_t tls_align size_t tls_cnt size_t page_size size_t global_locale struct{ cat [6]uintptr } } /* libc.h:20:1 */ type time_t = int64 /* alltypes.h:108:16 */ type clockid_t = int32 /* alltypes.h:237:13 */ type timespec = struct { tv_sec time_t tv_nsec int32 __12 uint32 /* int : 32 */ } /* alltypes.h:252:1 */ type __pthread = struct { self uintptr dtv uintptr prev uintptr next uintptr sysinfo uintptr_t canary uintptr_t canary2 uintptr_t tid int32 errno_val int32 detach_state int32 cancel int32 canceldisable uint8 cancelasync uint8 tsd_used uint8 /* unsigned char tsd_used: 1, unsigned char dlerror_flag: 1 */ _ [1]byte map_base uintptr map_size size_t stack uintptr stack_size size_t guard_size size_t result uintptr cancelbuf uintptr tsd uintptr robust_list struct { head uintptr off int32 pending uintptr } timer_id int32 locale locale_t killlock [1]int32 dlerror_buf uintptr stdio_locks uintptr canary_at_end uintptr_t dtv_copy uintptr } /* alltypes.h:296:9 */ type pthread_t = uintptr /* alltypes.h:296:26 */ type pthread_once_t = int32 /* alltypes.h:302:13 */ type pthread_key_t = uint32 /* alltypes.h:307:18 */ type pthread_spinlock_t = int32 /* alltypes.h:312:13 */ type pthread_mutexattr_t = struct{ __attr uint32 } /* alltypes.h:317:37 */ type pthread_condattr_t = struct{ __attr uint32 } /* alltypes.h:322:37 */ type pthread_barrierattr_t = struct{ __attr uint32 } /* alltypes.h:327:37 */ type pthread_rwlockattr_t = struct{ __attr [2]uint32 } /* alltypes.h:332:40 */ type __sigset_t = struct{ __bits [32]uint32 } /* alltypes.h:372:9 */ type sigset_t = __sigset_t /* alltypes.h:372:71 */ type pthread_attr_t = struct{ __u struct{ __i [9]int32 } } /* alltypes.h:395:147 */ type pthread_mutex_t = struct{ __u struct{ __i [6]int32 } } /* alltypes.h:400:157 */ type pthread_cond_t = struct{ __u struct{ __i [12]int32 } } /* alltypes.h:410:112 */ type pthread_rwlock_t = struct{ __u struct{ __i [8]int32 } } /* alltypes.h:420:139 */ type pthread_barrier_t = struct{ __u struct{ __i [5]int32 } } /* alltypes.h:425:137 */ type sched_param = struct { sched_priority int32 __reserved1 int32 __reserved2 [4]int32 __reserved3 int32 } /* sched.h:19:1 */ type timer_t = uintptr /* alltypes.h:232:14 */ type clock_t = int32 /* alltypes.h:242:14 */ type itimerspec = struct { it_interval struct { tv_sec time_t tv_nsec int32 __12 uint32 /* int : 32 */ } it_value struct { tv_sec time_t tv_nsec int32 __12 uint32 /* int : 32 */ } } /* time.h:80:1 */ type sigevent = struct { sigev_value struct{ sival_int int32 } sigev_signo int32 sigev_notify int32 sigev_notify_function uintptr sigev_notify_attributes uintptr __pad [44]int8 } /* time.h:107:1 */ type __ptcb = struct { __f uintptr __x uintptr __next uintptr } /* alltypes.h:296:9 */ type sigaltstack = struct { ss_sp uintptr ss_flags int32 ss_size size_t } /* signal.h:44:9 */ type stack_t = sigaltstack /* signal.h:44:28 */ type greg_t = int32 /* signal.h:51:13 */ type gregset_t = [19]int32 /* signal.h:51:21 */ type _fpstate = struct { cw uint32 sw uint32 tag uint32 ipoff uint32 cssel uint32 dataoff uint32 datasel uint32 _st [8]struct { significand [4]uint16 exponent uint16 } status uint32 } /* signal.h:52:9 */ type fpregset_t = uintptr /* signal.h:58:3 */ type sigcontext = struct { gs uint16 __gsh uint16 fs uint16 __fsh uint16 es uint16 __esh uint16 ds uint16 __dsh uint16 edi uint32 esi uint32 ebp uint32 esp uint32 ebx uint32 edx uint32 ecx uint32 eax uint32 trapno uint32 err uint32 eip uint32 cs uint16 __csh uint16 eflags uint32 esp_at_signal uint32 ss uint16 __ssh uint16 fpstate uintptr oldmask uint32 cr2 uint32 } /* signal.h:59:1 */ type mcontext_t = struct { gregs gregset_t fpregs fpregset_t oldmask uint32 cr2 uint32 } /* signal.h:73:3 */ type __ucontext = struct { uc_flags uint32 uc_link uintptr uc_stack stack_t uc_mcontext mcontext_t uc_sigmask sigset_t __fpregs_mem [28]uint32 } /* signal.h:86:9 */ type ucontext_t = __ucontext /* signal.h:93:3 */ type sigval = struct{ sival_int int32 } /* time.h:107:1 */ type siginfo_t = struct { si_signo int32 si_errno int32 si_code int32 __si_fields struct { _ [0]uint32 __pad [116]int8 } } /* signal.h:145:3 */ type sigaction = struct { __sa_handler struct{ sa_handler uintptr } sa_mask sigset_t sa_flags int32 sa_restorer uintptr } /* signal.h:167:1 */ type sig_t = uintptr /* signal.h:251:14 */ type sig_atomic_t = int32 /* signal.h:269:13 */ type mode_t = uint32 /* alltypes.h:175:18 */ type syscall_arg_t = int32 /* syscall.h:22:14 */ func a_cas(tls *TLS, p uintptr, t int32, s int32) int32 { /* atomic_arch.h:2:19: */ panic(`arch/i386/atomic_arch.h:4:2: assembler statements not supported`) return t } func a_and(tls *TLS, p uintptr, v int32) { /* atomic_arch.h:29:20: */ panic(`arch/i386/atomic_arch.h:31:2: assembler statements not supported`) } func a_or(tls *TLS, p uintptr, v int32) { /* atomic_arch.h:37:20: */ panic(`arch/i386/atomic_arch.h:39:2: assembler statements not supported`) } func a_ctz_64(tls *TLS, x uint64_t) int32 { /* atomic_arch.h:87:19: */ var r int32 panic(`arch/i386/atomic_arch.h:90:2: assembler statements not supported`) return r } func a_ctz_32(tls *TLS, x uint32_t) int32 { /* atomic_arch.h:96:19: */ var r int32 panic(`arch/i386/atomic_arch.h:99:2: assembler statements not supported`) return r } func a_clz_32(tls *TLS, x uint32_t) int32 { /* atomic_arch.h:104:19: */ panic(`arch/i386/atomic_arch.h:106:2: assembler statements not supported`) return int32(x) } func a_or_64(tls *TLS, p uintptr, v uint64_t) { /* atomic.h:220:20: */ bp := tls.Alloc(8) defer tls.Free(8) *(*struct{ v uint64_t })(unsafe.Pointer(bp /* u */)) = func() (r struct{ v uint64_t }) { *(*uint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = v return r }() if *(*uint32_t)(unsafe.Pointer((bp /* &u */ /* &.r */))) != 0 { a_or(tls, p, int32(*(*uint32_t)(unsafe.Pointer((bp /* &u */ /* &.r */))))) } if *(*uint32_t)(unsafe.Pointer((bp /* &u */ /* &.r */) + 1*4)) != 0 { a_or(tls, (p + uintptr(1)*4), int32(*(*uint32_t)(unsafe.Pointer((bp /* &u */ /* &.r */) + 1*4)))) } } type a_cas_p_undefined_but_pointer_not_32bit = [1]int8 /* atomic.h:229:14 */ type __timer = struct { timerid int32 thread pthread_t } /* pthread_impl.h:64:1 */ func __pthread_self(tls *TLS) uintptr { /* pthread_arch.h:1:30: */ var self uintptr panic(`arch/i386/pthread_arch.h:4:2: assembler statements not supported`) return self } func Xwcrtomb(tls *TLS, s uintptr, wc wchar_t, st uintptr) size_t { /* wcrtomb.c:6:8: */ if !(s != 0) { return size_t(1) } if uint32(wc) < uint32(0x80) { *(*int8)(unsafe.Pointer(s)) = int8(wc) return size_t(1) } else if (func() int32 { if !(!(int32(*(*uintptr)(unsafe.Pointer(((*__pthread)(unsafe.Pointer(__pthread_self(tls))).locale /* &.cat */)))) != 0)) { return 4 } return 1 }()) == 1 { if !(((uint32(wc)) - uint32(0xdf80)) < uint32(0x80)) { (*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 84 return Uint32FromInt32(-1) } *(*int8)(unsafe.Pointer(s)) = int8(wc) return size_t(1) } else if uint32(wc) < uint32(0x800) { *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0xc0 | (int32(wc) >> 6))) *(*int8)(unsafe.Pointer(s)) = (int8(0x80 | (int32(wc) & 0x3f))) return size_t(2) } else if (uint32(wc) < uint32(0xd800)) || ((uint32(wc) - uint32(0xe000)) < uint32(0x2000)) { *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0xe0 | (int32(wc) >> 12))) *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0x80 | ((int32(wc) >> 6) & 0x3f))) *(*int8)(unsafe.Pointer(s)) = (int8(0x80 | (int32(wc) & 0x3f))) return size_t(3) } else if (uint32(wc) - uint32(0x10000)) < uint32(0x100000) { *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0xf0 | (int32(wc) >> 18))) *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0x80 | ((int32(wc) >> 12) & 0x3f))) *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = (int8(0x80 | ((int32(wc) >> 6) & 0x3f))) *(*int8)(unsafe.Pointer(s)) = (int8(0x80 | (int32(wc) & 0x3f))) return size_t(4) } (*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 84 return Uint32FromInt32(-1) } func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n size_t, st uintptr) size_t { /* wcsrtombs.c:3:8: */ bp := tls.Alloc(4) defer tls.Free(4) var ws2 uintptr // var buf [4]int8 at bp, 4 var N size_t = n var l size_t if !(s != 0) { n = size_t(0) ws2 = *(*uintptr)(unsafe.Pointer(ws)) for ; *(*wchar_t)(unsafe.Pointer(ws2)) != 0; ws2 += 2 { if uint32(*(*wchar_t)(unsafe.Pointer(ws2))) >= 0x80 { l = Xwcrtomb(tls, bp /* &buf[0] */, *(*wchar_t)(unsafe.Pointer(ws2)), uintptr(0)) if !((l + size_t(1)) != 0) { return Uint32FromInt32(-1) } n = n + (l) } else { n++ } } return n } for n >= size_t(4) { if (uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - 1) >= 0x7f { if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) { *(*int8)(unsafe.Pointer(s)) = int8(0) *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) return (N - n) } l = Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) if !((l + size_t(1)) != 0) { return Uint32FromInt32(-1) } s += uintptr(l) n = n - (l) } else { *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) n-- } (*(*uintptr)(unsafe.Pointer(ws))) += 2 } for n != 0 { if (uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - 1) >= 0x7f { if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) { *(*int8)(unsafe.Pointer(s)) = int8(0) *(*uintptr)(unsafe.Pointer(ws)) = uintptr(0) return (N - n) } l = Xwcrtomb(tls, bp /* &buf[0] */, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) if !((l + size_t(1)) != 0) { return Uint32FromInt32(-1) } if l > n { return (N - n) } Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) s += uintptr(l) n = n - (l) } else { *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) n-- } (*(*uintptr)(unsafe.Pointer(ws))) += 2 } return N } func Xwcstombs(tls *TLS, s uintptr, ws uintptr, n size_t) size_t { /* wcstombs.c:4:8: */ bp := tls.Alloc(4) defer tls.Free(4) *(*uintptr)(unsafe.Pointer(bp)) = ws //TODO return wcsrtombs(s, &(const wchar_t *){ws}, n, 0); return Xwcsrtombs(tls, s, bp /* &ws */, n, uintptr(0)) } // Support signed or unsigned plain-char // Implementation choices... // Arbitrary numbers... // POSIX/SUS requirements follow. These numbers come directly // from SUS and have nothing to do with the host system. func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr { /* strchrnul.c:10:6: */ c = int32(uint8(c)) if !(c != 0) { return (s + uintptr(Xstrlen(tls, s))) } var w uintptr for ; (uintptr_t(s) % (uintptr_t(unsafe.Sizeof(size_t(0))))) != 0; s++ { if !(int32(*(*int8)(unsafe.Pointer(s))) != 0) || (int32(*(*uint8)(unsafe.Pointer(s))) == c) { return s } } var k size_t = ((Uint32(Uint32FromInt32(-1)) / size_t(255)) * size_t(c)) for w = s; !(((((*(*uint32)(unsafe.Pointer(w))) - (Uint32(Uint32FromInt32(-1)) / size_t(255))) & ^(*(*uint32)(unsafe.Pointer(w)))) & ((Uint32(Uint32FromInt32(-1)) / size_t(255)) * (size_t((255 / 2) + 1)))) != 0) && !(((((*(*uint32)(unsafe.Pointer(w)) ^ k) - (Uint32(Uint32FromInt32(-1)) / size_t(255))) & ^(*(*uint32)(unsafe.Pointer(w)) ^ k)) & ((Uint32(Uint32FromInt32(-1)) / size_t(255)) * (size_t((255 / 2) + 1)))) != 0); w += 4 { } s = w for ; (*(*int8)(unsafe.Pointer(s)) != 0) && (int32(*(*uint8)(unsafe.Pointer(s))) != c); s++ { } return s } func Xstrdup(tls *TLS, s uintptr) uintptr { /* strdup.c:4:6: */ var l size_t = Xstrlen(tls, s) var d uintptr = Xmalloc(tls, (l + size_t(1))) if !(d != 0) { return uintptr(0) } return Xmemcpy(tls, d, s, (l + size_t(1))) }