From mboxrd@z Thu Jan 1 00:00:00 1970 From: Nicola Pero To: nobody@gcc.gnu.org Cc: gcc-prs@gcc.gnu.org Subject: Re: objc/3110: Followup to bug 3072, maybe 3019 too Date: Mon, 11 Jun 2001 02:56:00 -0000 Message-id: <20010611095601.10860.qmail@sourceware.cygnus.com> X-SW-Source: 2001-06/msg00398.html List-Id: The following reply was made to PR objc/3110; it has been noted by GNATS. From: Nicola Pero To: jones.peter@uqam.ca Cc: gcc-gnats@gcc.gnu.org, nobody@gcc.gnu.org, gcc-prs@gcc.gnu.org, gcc-bugs@gcc.gnu.org Subject: Re: objc/3110: Followup to bug 3072, maybe 3019 too Date: Mon, 11 Jun 2001 10:49:35 +0100 (BST) Hi, this bug is the inline nested function bug which was fixed on 2001-06-05. Please get a more recent gcc-3.0 and it should work. > >Number: 3110 > >Category: objc > >Synopsis: Followup to bug 3072, maybe 3019 too > >Confidential: no > >Severity: serious > >Priority: medium > >Responsible: unassigned > >State: open > >Class: sw-bug > >Submitter-Id: net > >Arrival-Date: Sun Jun 10 14:26:01 PDT 2001 > >Closed-Date: > >Last-Modified: > >Originator: Swarm > >Release: 3.0 20010528 (prerelease) > >Organization: > >Environment: > System: Linux localhost.localdomain 2.4.2-2 #1 Sun Apr 8 20:41:30 EDT 2001 i686 unknown > Architecture: i686 > > > host: i686-pc-linux-gnu > build: i686-pc-linux-gnu > target: i686-pc-linux-gnu > configured with: ../gcc/configure > >Description: > > Compiling attached mff.mi file gives ICE > >How-To-Repeat: > > 1) Download gcc snapshot from www.codesourcery.com > 2) Install > 3) /usr/local/bin/gcc -v > 4) /usr/local/bin/gcc mff.mi > > >Fix: > > ------ File gcc386.out ------ begins > gcc command is /usr/local/bin/gcc --save-temps > Compiler version: > Reading specs from /usr/local/bin/../lib/gcc-lib/i386-pc-linux-gnu/3.0/specs > Configured with: ../configure --prefix=/tmp/gcc-20010604-root/usr/local --enable-shared --enable-threads --disable-checking i386-pc-linux-gnu > Thread model: posix > gcc version 3.0 20010604 (prerelease) > mff.mi: In function `mframe_decode_return': > mff.mi:2591: Internal compiler error in make_decl_rtl, at varasm.c:591 > Please submit a full bug report, > with preprocessed source if appropriate. > See for instructions. > --------------------- File ends ------------------- > In the following file, I have introduced an extra new-line in the file > as produced by gcc, in routing compare_strings > ------ File mff.mi ------ begins > typedef int ptrdiff_t; > typedef unsigned int size_t; > typedef long int wchar_t; > typedef unsigned char BOOL; > typedef const struct objc_selector > { > void *sel_id; > const char *sel_types; > } *SEL; > inline static BOOL > sel_eq (SEL s1, SEL s2) > { > if (s1 == 0 || s2 == 0) > return s1 == s2; > else > return s1->sel_id == s2->sel_id; > } > typedef struct objc_object { > struct objc_class* class_pointer; > } *id; > typedef id (*IMP)(id, SEL, ...); > typedef char *STR; > typedef struct objc_class *MetaClass; > typedef struct objc_class *Class; > struct objc_class { > MetaClass class_pointer; > struct objc_class* super_class; > const char* name; > long version; > unsigned long info; > long instance_size; > struct objc_ivar_list* ivars; > struct objc_method_list* methods; > struct sarray * dtable; > struct objc_class* subclass_list; > struct objc_class* sibling_class; > struct objc_protocol_list *protocols; > void* gc_object_type; > }; > @class Protocol; > typedef void* retval_t; > typedef void(*apply_t)(void); > typedef union { > char *arg_ptr; > char arg_regs[sizeof (char*)]; > } *arglist_t; > IMP objc_msg_lookup (id receiver, SEL op); > extern void *memcpy (void *__restrict __dest, > __const void *__restrict __src, size_t __n) ; > extern void *memmove (void *__dest, __const void *__src, size_t __n) > ; > extern void *memccpy (void *__restrict __dest, __const void *__restrict __src, > int __c, size_t __n) > ; > extern void *memset (void *__s, int __c, size_t __n) ; > extern int memcmp (__const void *__s1, __const void *__s2, size_t __n) > __attribute__ ((__pure__)); > extern void *memchr (__const void *__s, int __c, size_t __n) > __attribute__ ((__pure__)); > extern char *strcpy (char *__restrict __dest, __const char *__restrict __src) > ; > extern char *strncpy (char *__restrict __dest, > __const char *__restrict __src, size_t __n) ; > extern char *strcat (char *__restrict __dest, __const char *__restrict __src) > ; > extern char *strncat (char *__restrict __dest, __const char *__restrict __src, > size_t __n) ; > extern int strcmp (__const char *__s1, __const char *__s2) > __attribute__ ((__pure__)); > extern int strncmp (__const char *__s1, __const char *__s2, size_t __n) > __attribute__ ((__pure__)); > extern int strcoll (__const char *__s1, __const char *__s2) > __attribute__ ((__pure__)); > extern size_t strxfrm (char *__restrict __dest, > __const char *__restrict __src, size_t __n) ; > extern char *strdup (__const char *__s) __attribute__ ((__malloc__)); > extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__)); > extern char *strrchr (__const char *__s, int __c) __attribute__ ((__pure__)); > extern size_t strcspn (__const char *__s, __const char *__reject) > __attribute__ ((__pure__)); > extern size_t strspn (__const char *__s, __const char *__accept) > __attribute__ ((__pure__)); > extern char *strpbrk (__const char *__s, __const char *__accept) > __attribute__ ((__pure__)); > extern char *strstr (__const char *__haystack, __const char *__needle) > __attribute__ ((__pure__)); > extern char *strtok (char *__restrict __s, __const char *__restrict __delim) > ; > extern char *__strtok_r (char *__restrict __s, > __const char *__restrict __delim, > char **__restrict __save_ptr) ; > extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim, > char **__restrict __save_ptr) ; > extern size_t strlen (__const char *__s) __attribute__ ((__pure__)); > extern char *strerror (int __errnum) ; > extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) ; > extern void __bzero (void *__s, size_t __n) ; > extern void bcopy (__const void *__src, void *__dest, size_t __n) ; > extern void bzero (void *__s, size_t __n) ; > extern int bcmp (__const void *__s1, __const void *__s2, size_t __n) > __attribute__ ((__pure__)); > extern char *index (__const char *__s, int __c) __attribute__ ((__pure__)); > extern char *rindex (__const char *__s, int __c) __attribute__ ((__pure__)); > extern int ffs (int __i) __attribute__ ((const)); > extern int strcasecmp (__const char *__s1, __const char *__s2) > __attribute__ ((__pure__)); > extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n) > __attribute__ ((__pure__)); > extern char *strsep (char **__restrict __stringp, > __const char *__restrict __delim) ; > typedef unsigned char __u_char; > typedef unsigned short __u_short; > typedef unsigned int __u_int; > typedef unsigned long __u_long; > __extension__ typedef unsigned long long int __u_quad_t; > __extension__ typedef long long int __quad_t; > typedef signed char __int8_t; > typedef unsigned char __uint8_t; > typedef signed short int __int16_t; > typedef unsigned short int __uint16_t; > typedef signed int __int32_t; > typedef unsigned int __uint32_t; > __extension__ typedef signed long long int __int64_t; > __extension__ typedef unsigned long long int __uint64_t; > typedef __quad_t *__qaddr_t; > typedef __u_quad_t __dev_t; > typedef __u_int __uid_t; > typedef __u_int __gid_t; > typedef __u_long __ino_t; > typedef __u_int __mode_t; > typedef __u_int __nlink_t; > typedef long int __off_t; > typedef __quad_t __loff_t; > typedef int __pid_t; > typedef int __ssize_t; > typedef __u_long __rlim_t; > typedef __u_quad_t __rlim64_t; > typedef __u_int __id_t; > typedef struct > { > int __val[2]; > } __fsid_t; > typedef int __daddr_t; > typedef char *__caddr_t; > typedef long int __time_t; > typedef unsigned int __useconds_t; > typedef long int __suseconds_t; > typedef long int __swblk_t; > typedef long int __clock_t; > typedef int __clockid_t; > typedef int __timer_t; > typedef int __key_t; > typedef unsigned short int __ipc_pid_t; > typedef long int __blksize_t; > typedef long int __blkcnt_t; > typedef __quad_t __blkcnt64_t; > typedef __u_long __fsblkcnt_t; > typedef __u_quad_t __fsblkcnt64_t; > typedef __u_long __fsfilcnt_t; > typedef __u_quad_t __fsfilcnt64_t; > typedef __u_quad_t __ino64_t; > typedef __loff_t __off64_t; > typedef long int __t_scalar_t; > typedef unsigned long int __t_uscalar_t; > typedef int __intptr_t; > typedef unsigned int __socklen_t; > struct __sched_param > { > int __sched_priority; > }; > struct _pthread_fastlock > { > long int __status; > int __spinlock; > }; > typedef struct _pthread_descr_struct *_pthread_descr; > typedef struct __pthread_attr_s > { > int __detachstate; > int __schedpolicy; > struct __sched_param __schedparam; > int __inheritsched; > int __scope; > size_t __guardsize; > int __stackaddr_set; > void *__stackaddr; > size_t __stacksize; > } pthread_attr_t; > typedef struct > { > struct _pthread_fastlock __c_lock; > _pthread_descr __c_waiting; > } pthread_cond_t; > typedef struct > { > int __dummy; > } pthread_condattr_t; > typedef unsigned int pthread_key_t; > typedef struct > { > int __m_reserved; > int __m_count; > _pthread_descr __m_owner; > int __m_kind; > struct _pthread_fastlock __m_lock; > } pthread_mutex_t; > typedef struct > { > int __mutexkind; > } pthread_mutexattr_t; > typedef int pthread_once_t; > typedef unsigned long int pthread_t; > extern void *__rawmemchr (const void *__s, int __c); > extern __inline char *__strcpy_small (char *, __uint16_t, __uint16_t, > __uint32_t, __uint32_t, size_t); > extern __inline char * > __strcpy_small (char *__dest, > __uint16_t __src0_2, __uint16_t __src4_2, > __uint32_t __src0_4, __uint32_t __src4_4, > size_t __srclen) > { > union { > __uint32_t __ui; > __uint16_t __usi; > unsigned char __uc; > } *__u = (void *) __dest; > switch ((unsigned int) __srclen) > { > case 1: > __u->__uc = '\0'; > break; > case 2: > __u->__usi = __src0_2; > break; > case 3: > __u->__usi = __src0_2; > __u = __extension__ ((void *) __u + 2); > __u->__uc = '\0'; > break; > case 4: > __u->__ui = __src0_4; > break; > case 5: > __u->__ui = __src0_4; > __u = __extension__ ((void *) __u + 4); > __u->__uc = '\0'; > break; > case 6: > __u->__ui = __src0_4; > __u = __extension__ ((void *) __u + 4); > __u->__usi = __src4_2; > break; > case 7: > __u->__ui = __src0_4; > __u = __extension__ ((void *) __u + 4); > __u->__usi = __src4_2; > __u = __extension__ ((void *) __u + 2); > __u->__uc = '\0'; > break; > case 8: > __u->__ui = __src0_4; > __u = __extension__ ((void *) __u + 4); > __u->__ui = __src4_4; > break; > } > return __dest; > } > extern __inline size_t __strcspn_c1 (__const char *__s, char __reject); > extern __inline size_t > __strcspn_c1 (__const char *__s, char __reject) > { > register size_t __result = 0; > while (__s[__result] != '\0' && __s[__result] != __reject) > ++__result; > return __result; > } > extern __inline size_t __strcspn_c2 (__const char *__s, char __reject1, > char __reject2); > extern __inline size_t > __strcspn_c2 (__const char *__s, char __reject1, char __reject2) > { > register size_t __result = 0; > while (__s[__result] != '\0' && __s[__result] != __reject1 > && __s[__result] != __reject2) > ++__result; > return __result; > } > extern __inline size_t __strcspn_c3 (__const char *__s, char __reject1, > char __reject2, char __reject3); > extern __inline size_t > __strcspn_c3 (__const char *__s, char __reject1, char __reject2, > char __reject3) > { > register size_t __result = 0; > while (__s[__result] != '\0' && __s[__result] != __reject1 > && __s[__result] != __reject2 && __s[__result] != __reject3) > ++__result; > return __result; > } > extern __inline size_t __strspn_c1 (__const char *__s, char __accept); > extern __inline size_t > __strspn_c1 (__const char *__s, char __accept) > { > register size_t __result = 0; > while (__s[__result] == __accept) > ++__result; > return __result; > } > extern __inline size_t __strspn_c2 (__const char *__s, char __accept1, > char __accept2); > extern __inline size_t > __strspn_c2 (__const char *__s, char __accept1, char __accept2) > { > register size_t __result = 0; > while (__s[__result] == __accept1 || __s[__result] == __accept2) > ++__result; > return __result; > } > extern __inline size_t __strspn_c3 (__const char *__s, char __accept1, > char __accept2, char __accept3); > extern __inline size_t > __strspn_c3 (__const char *__s, char __accept1, char __accept2, char __accept3) > { > register size_t __result = 0; > while (__s[__result] == __accept1 || __s[__result] == __accept2 > || __s[__result] == __accept3) > ++__result; > return __result; > } > extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1, > int __accept2); > extern __inline char * > __strpbrk_c2 (__const char *__s, int __accept1, int __accept2) > { > while (*__s != '\0' && *__s != __accept1 && *__s != __accept2) > ++__s; > return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s; > } > extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1, > int __accept2, int __accept3); > extern __inline char * > __strpbrk_c3 (__const char *__s, int __accept1, int __accept2, > int __accept3) > { > while (*__s != '\0' && *__s != __accept1 && *__s != __accept2 > && *__s != __accept3) > ++__s; > return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s; > } > extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp); > extern __inline char * > __strtok_r_1c (char *__s, char __sep, char **__nextp) > { > char *__result; > if (__s == ((void *)0)) > __s = *__nextp; > while (*__s == __sep) > ++__s; > if (*__s == '\0') > __result = ((void *)0); > else > { > __result = __s; > while (*__s != '\0' && *__s != __sep) > ++__s; > if (*__s == '\0') > *__nextp = __s; > else > { > *__s = '\0'; > *__nextp = __s + 1; > } > } > return __result; > } > extern __inline char *__strsep_1c (char **__s, char __reject); > extern __inline char * > __strsep_1c (char **__s, char __reject) > { > register char *__retval = *__s; > if (__retval == ((void *)0)) > return *__s = ((void *)0); > if (*__retval == __reject) > *(*__s)++ = '\0'; > else > if ((*__s = (__extension__ (__builtin_constant_p (__reject) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : strchr (__retval, __reject)))) != ((void *)0)) > *(*__s)++ = '\0'; > else > *__s = ((void *)0); > return __retval; > } > extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2); > extern __inline char * > __strsep_2c (char **__s, char __reject1, char __reject2) > { > register char *__retval = *__s; > if (__retval == ((void *)0)) > return *__s = ((void *)0); > if (*__retval == __reject1 || *__retval == __reject2) > *(*__s)++ = '\0'; > else > { > register char *__cp = __retval; > while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2) > ++__cp; > if (*__cp != '\0') > { > *__s = __cp; > *(*__s)++ = '\0'; > } > else > *__s = ((void *)0); > } > return __retval; > } > extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2, > char __reject3); > extern __inline char * > __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3) > { > register char *__retval = *__s; > if (__retval == ((void *)0)) > return *__s = ((void *)0); > if (*__retval == __reject1 || *__retval == __reject2 > || *__retval == __reject3) > *(*__s)++ = '\0'; > else > { > register char *__cp = __retval; > while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2 > && *__cp != __reject3) > ++__cp; > if (*__cp != '\0') > { > *__s = __cp; > *(*__s)++ = '\0'; > } > else > *__s = ((void *)0); > } > return __retval; > } > extern __inline char *__strsep_g (char **__s, __const char *__reject); > extern __inline char * > __strsep_g (char **__s, __const char *__reject) > { > register char *__retval = *__s; > if (__retval == ((void *)0)) > return ((void *)0); > if ((*__s = __extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (__reject) && ((size_t)(const void *)((__reject) + 1) - (size_t)(const void *)(__reject) == 1) ? ((__a0 = ((__const char *) (__reject))[0], __a0 == '\0') ? ((void) (__retval), ((void *)0)) : ((__a1 = ((__const char *) (__reject))[1], __a1 == '\0') ? (__extension__ (__builtin_constant_p (__a0) && (__a0) == '\0' ? (char *) __rawmemchr (__retval, __a0) : strchr (__retval, __a0))) : ((__a2 = ((__const char *) (__reject))[2], __a2 == '\0') ? __strpbrk_c2 (__retval, __a0, __a1) : (((__const char *) (__reject))[3] == '\0' ? __strpbrk_c3 (__retval, __a0, __a1, __a2) : strpbrk (__retval, __reject))))) : strpbrk (__retval, __reject)); })) != ((void *)0)) > *(*__s)++ = '\0'; > return __retval; > } > extern void *malloc (size_t __size) __attribute__ ((__malloc__)); > extern void *calloc (size_t __nmemb, size_t __size) > __attribute__ ((__malloc__)); > extern char *__strdup (__const char *__string) __attribute__ ((__malloc__)); > extern char *__strndup (__const char *__string, size_t __n) > __attribute__ ((__malloc__)); > typedef struct cache_node > { > struct cache_node *next; > const void *key; > void *value; > } *node_ptr; > typedef unsigned int (*hash_func_type)(void *, const void *); > typedef int (*compare_func_type)(const void *, const void *); > typedef struct > { > node_ptr *node_table; > unsigned int size; > unsigned int used; > unsigned int mask; > unsigned int last_bucket; > hash_func_type hash_func; > compare_func_type compare_func; > } cache_t; > typedef cache_t *cache_ptr; > extern cache_ptr module_hash_table, class_hash_table; > cache_ptr hash_new (unsigned int size, > hash_func_type hash_func, > compare_func_type compare_func); > void hash_delete (cache_ptr cache); > void hash_add (cache_ptr *cachep, const void *key, void *value); > void hash_remove (cache_ptr cache, const void *key); > node_ptr hash_next (cache_ptr cache, node_ptr node); > void *hash_value_for_key (cache_ptr cache, const void *key); > BOOL hash_is_key_in_hash (cache_ptr cache, const void *key); > static inline unsigned int > hash_ptr (cache_ptr cache, const void *key) > { > return ((size_t)key / sizeof (void *)) & cache->mask; > } > static inline unsigned int > hash_string (cache_ptr cache, const void *key) > { > unsigned int ret = 0; > unsigned int ctr = 0; > while (*(char*)key) { > ret ^= *(char*)key++ << ctr; > ctr = (ctr + 1) % sizeof (void *); > } > return ret & cache->mask; > } > static inline int > compare_ptrs (const void *k1, const void *k2) > { > return !(k1 - k2); > } > static inline int > compare_strings (const void *k1, const void *k2) > { > if (k1 == k2) > return 1; > else if (k1 == 0 || k2 == 0) > return 0; > else > return !__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (k1) && __builtin_constant_p (k2) && (__s1_len = strlen (k1), __s2_len = strlen (k2), (!((size_t)(const void *)((k1) + 1) - (size_t)(const void *)(k1) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((k2) + 1) - (size_t)(const void *)(k2) == 1) || __s2_len >= 4)) ? memcmp ((__const char *) (k1), (__const char *) (k2), (__s1_len < __s2_len ? __s1_len : __s2_len) + 1) : (__builtin_constant_p (k1) && ((size_t)(const void *)((k 1) + 1) - (size_t)(const void *)(k1) == 1) && (__s1_len = strlen (k1), __s1_len < 4) ? (__builtin_constant_p (k2) && ((size_t)(const void *)((k2) + 1) - (size_t)(const void *)(k2) == 1) ? (__extension__ ({ register int __result = (((__const unsigned char *) (__const char *) (k1))[0] - ((__const unsigned char *) (__const char *)(k2))[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (k1))[1] - ((__const unsigned char *) (__cons! t ! > char *) (k2))[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (k1))[2] - ((__const unsigned char *) (__const char *) (k2))[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (k1))[3] - ((__const unsigned char *) (__const char *) (k2))[3]); } } __result; })) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (k2); register int __result = (((__const unsigned char *) (__c onst char *) (k1))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) > (__const char *) (k1))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (k1))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (k1))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (k2) && ((size_t)(const void *)((k2) + 1) - (size_t)(const void *)(k2) == 1) && (__s2_len = strlen (k2), __s2_len < 4) ? (__builtin_constant_p (k1) && ((size_t)(const void *)((k1) + 1) - (size_t)(const void *)(k1) == 1) ? (__extension__ ({ register int __result = (((__const unsigned char *) (__const char *) (k1))[0] - ((__const unsigned char *) (__const char *)(k2))[0]); if (__s2_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (k1))[1] - ((__const unsigned char *) (__const char *) (k2))[1]); if (__s2_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (k1))[2] - ((__const unsigned char *) (__const char *)! (! > k2))[2]); if (__s2_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (k1))[3] - ((__const unsigned char *) (__const char *) (k2))[3]); } } __result; })) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (k1); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (k2))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (k2))[1]); if (__s2_len > 1 && __ result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (k2))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (k2))[3]); } } __result; }))) : strcmp (k1, k2)))); }); > } > extern int __objc_thread_exit_status; > typedef void * objc_thread_t; > struct objc_mutex > { > volatile objc_thread_t owner; > volatile int depth; > void * backend; > }; > typedef struct objc_mutex *objc_mutex_t; > struct objc_condition > { > void * backend; > }; > typedef struct objc_condition *objc_condition_t; > objc_mutex_t objc_mutex_allocate(void); > int objc_mutex_deallocate(objc_mutex_t mutex); > int objc_mutex_lock(objc_mutex_t mutex); > int objc_mutex_unlock(objc_mutex_t mutex); > int objc_mutex_trylock(objc_mutex_t mutex); > objc_condition_t objc_condition_allocate(void); > int objc_condition_deallocate(objc_condition_t condition); > int objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex); > int objc_condition_signal(objc_condition_t condition); > int objc_condition_broadcast(objc_condition_t condition); > objc_thread_t objc_thread_detach(SEL selector, id object, id argument); > void objc_thread_yield(void); > int objc_thread_exit(void); > int objc_thread_set_priority(int priority); > int objc_thread_get_priority(void); > void * objc_thread_get_data(void); > int objc_thread_set_data(void *value); > objc_thread_t objc_thread_id(void); > typedef void (*objc_thread_callback)(); > objc_thread_callback objc_set_thread_callback(objc_thread_callback func); > int __objc_init_thread_system(void); > int __objc_fini_thread_system(void); > int __objc_mutex_allocate(objc_mutex_t mutex); > int __objc_mutex_deallocate(objc_mutex_t mutex); > int __objc_mutex_lock(objc_mutex_t mutex); > int __objc_mutex_trylock(objc_mutex_t mutex); > int __objc_mutex_unlock(objc_mutex_t mutex); > int __objc_condition_allocate(objc_condition_t condition); > int __objc_condition_deallocate(objc_condition_t condition); > int __objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex); > int __objc_condition_broadcast(objc_condition_t condition); > int __objc_condition_signal(objc_condition_t condition); > objc_thread_t __objc_thread_detach(void (*func)(void *arg), void *arg); > int __objc_thread_set_priority(int priority); > int __objc_thread_get_priority(void); > void __objc_thread_yield(void); > int __objc_thread_exit(void); > objc_thread_t __objc_thread_id(void); > int __objc_thread_set_data(void *value); > void * __objc_thread_get_data(void); > typedef struct _IO_FILE FILE; > typedef struct _IO_FILE __FILE; > typedef unsigned int wint_t; > typedef struct > { > int __count; > union > { > wint_t __wch; > char __wchb[4]; > } __value; > } __mbstate_t; > typedef struct > { > __off_t __pos; > __mbstate_t __state; > } _G_fpos_t; > typedef struct > { > __off64_t __pos; > __mbstate_t __state; > } _G_fpos64_t; > enum > { > __GCONV_OK = 0, > __GCONV_NOCONV, > __GCONV_NODB, > __GCONV_NOMEM, > __GCONV_EMPTY_INPUT, > __GCONV_FULL_OUTPUT, > __GCONV_ILLEGAL_INPUT, > __GCONV_INCOMPLETE_INPUT, > __GCONV_ILLEGAL_DESCRIPTOR, > __GCONV_INTERNAL_ERROR > }; > enum > { > __GCONV_IS_LAST = 0x0001, > __GCONV_IGNORE_ERRORS = 0x0002 > }; > struct __gconv_step; > struct __gconv_step_data; > struct __gconv_loaded_object; > struct __gconv_trans_data; > typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *, > __const unsigned char **, __const unsigned char *, > unsigned char **, size_t *, int, int); > typedef int (*__gconv_init_fct) (struct __gconv_step *); > typedef void (*__gconv_end_fct) (struct __gconv_step *); > typedef int (*__gconv_trans_fct) (struct __gconv_step *, > struct __gconv_step_data *, void *, > __const unsigned char *, > __const unsigned char **, > __const unsigned char *, unsigned char **, > size_t *); > typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *, > __const unsigned char *, > unsigned char *, unsigned char *); > typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***, > size_t *); > typedef int (*__gconv_trans_init_fct) (void **, const char *); > typedef void (*__gconv_trans_end_fct) (void *); > struct __gconv_trans_data > { > __gconv_trans_fct __trans_fct; > __gconv_trans_context_fct __trans_context_fct; > __gconv_trans_end_fct __trans_end_fct; > void *__data; > struct __gconv_trans_data *__next; > }; > struct __gconv_step > { > struct __gconv_loaded_object *__shlib_handle; > __const char *__modname; > int __counter; > char *__from_name; > char *__to_name; > __gconv_fct __fct; > __gconv_init_fct __init_fct; > __gconv_end_fct __end_fct; > int __min_needed_from; > int __max_needed_from; > int __min_needed_to; > int __max_needed_to; > int __stateful; > void *__data; > }; > struct __gconv_step_data > { > unsigned char *__outbuf; > unsigned char *__outbufend; > int __flags; > int __invocation_counter; > int __internal_use; > __mbstate_t *__statep; > __mbstate_t __state; > struct __gconv_trans_data *__trans; > }; > typedef struct __gconv_info > { > size_t __nsteps; > struct __gconv_step *__steps; > __extension__ struct __gconv_step_data __data []; > } *__gconv_t; > typedef union > { > struct __gconv_info __cd; > struct > { > struct __gconv_info __cd; > struct __gconv_step_data __data; > } __combined; > } _G_iconv_t; > typedef int _G_int16_t __attribute__ ((__mode__ (__HI__))); > typedef int _G_int32_t __attribute__ ((__mode__ (__SI__))); > typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__))); > typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__))); > typedef __builtin_va_list __gnuc_va_list; > struct _IO_jump_t; struct _IO_FILE; > typedef void _IO_lock_t; > struct _IO_marker { > struct _IO_marker *_next; > struct _IO_FILE *_sbuf; > int _pos; > }; > enum __codecvt_result > { > __codecvt_ok, > __codecvt_partial, > __codecvt_error, > __codecvt_noconv > }; > struct _IO_FILE { > int _flags; > char* _IO_read_ptr; > char* _IO_read_end; > char* _IO_read_base; > char* _IO_write_base; > char* _IO_write_ptr; > char* _IO_write_end; > char* _IO_buf_base; > char* _IO_buf_end; > char *_IO_save_base; > char *_IO_backup_base; > char *_IO_save_end; > struct _IO_marker *_markers; > struct _IO_FILE *_chain; > int _fileno; > int _blksize; > __off_t _old_offset; > unsigned short _cur_column; > signed char _vtable_offset; > char _shortbuf[1]; > _IO_lock_t *_lock; > __off64_t _offset; > void *__pad1; > void *__pad2; > int _mode; > char _unused2[15 * sizeof (int) - 2 * sizeof (void *)]; > }; > typedef struct _IO_FILE _IO_FILE; > struct _IO_FILE_plus; > extern struct _IO_FILE_plus _IO_2_1_stdin_; > extern struct _IO_FILE_plus _IO_2_1_stdout_; > extern struct _IO_FILE_plus _IO_2_1_stderr_; > typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes); > typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf, > size_t __n); > typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w); > typedef int __io_close_fn (void *__cookie); > extern int __underflow (_IO_FILE *) ; > extern int __uflow (_IO_FILE *) ; > extern int __overflow (_IO_FILE *, int) ; > extern wint_t __wunderflow (_IO_FILE *) ; > extern wint_t __wuflow (_IO_FILE *) ; > extern wint_t __woverflow (_IO_FILE *, wint_t) ; > extern int _IO_getc (_IO_FILE *__fp) ; > extern int _IO_putc (int __c, _IO_FILE *__fp) ; > extern int _IO_feof (_IO_FILE *__fp) ; > extern int _IO_ferror (_IO_FILE *__fp) ; > extern int _IO_peekc_locked (_IO_FILE *__fp) ; > extern void _IO_flockfile (_IO_FILE *) ; > extern void _IO_funlockfile (_IO_FILE *) ; > extern int _IO_ftrylockfile (_IO_FILE *) ; > extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, > __gnuc_va_list, int *__restrict) ; > extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, > __gnuc_va_list) ; > extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) ; > extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) ; > extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) ; > extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) ; > extern void _IO_free_backup_area (_IO_FILE *) ; > typedef _G_fpos_t fpos_t; > extern FILE *stdin; > extern FILE *stdout; > extern FILE *stderr; > extern int remove (__const char *__filename) ; > extern int rename (__const char *__old, __const char *__new) ; > extern FILE *tmpfile (void) ; > extern char *tmpnam (char *__s) ; > extern char *tmpnam_r (char *__s) ; > extern char *tempnam (__const char *__dir, __const char *__pfx) > __attribute__ ((__malloc__)); > extern int fclose (FILE *__stream) ; > extern int fflush (FILE *__stream) ; > extern int fflush_unlocked (FILE *__stream) ; > extern FILE *fopen (__const char *__restrict __filename, > __const char *__restrict __modes) ; > extern FILE *freopen (__const char *__restrict __filename, > __const char *__restrict __modes, > FILE *__restrict __stream) ; > extern FILE *fdopen (int __fd, __const char *__modes) ; > extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) ; > extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, > int __modes, size_t __n) ; > extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, > size_t __size) ; > extern void setlinebuf (FILE *__stream) ; > extern int fprintf (FILE *__restrict __stream, > __const char *__restrict __format, ...) ; > extern int printf (__const char *__restrict __format, ...) ; > extern int sprintf (char *__restrict __s, > __const char *__restrict __format, ...) ; > extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format, > __gnuc_va_list __arg) ; > extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg) > ; > extern int vsprintf (char *__restrict __s, __const char *__restrict __format, > __gnuc_va_list __arg) ; > extern int snprintf (char *__restrict __s, size_t __maxlen, > __const char *__restrict __format, ...) > __attribute__ ((__format__ (__printf__, 3, 4))); > extern int vsnprintf (char *__restrict __s, size_t __maxlen, > __const char *__restrict __format, __gnuc_va_list __arg) > __attribute__ ((__format__ (__printf__, 3, 0))); > extern int fscanf (FILE *__restrict __stream, > __const char *__restrict __format, ...) ; > extern int scanf (__const char *__restrict __format, ...) ; > extern int sscanf (__const char *__restrict __s, > __const char *__restrict __format, ...) ; > extern int fgetc (FILE *__stream) ; > extern int getc (FILE *__stream) ; > extern int getchar (void) ; > extern int getc_unlocked (FILE *__stream) ; > extern int getchar_unlocked (void) ; > extern int fgetc_unlocked (FILE *__stream) ; > extern int fputc (int __c, FILE *__stream) ; > extern int putc (int __c, FILE *__stream) ; > extern int putchar (int __c) ; > extern int fputc_unlocked (int __c, FILE *__stream) ; > extern int putc_unlocked (int __c, FILE *__stream) ; > extern int putchar_unlocked (int __c) ; > extern int getw (FILE *__stream) ; > extern int putw (int __w, FILE *__stream) ; > extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) > ; > extern char *gets (char *__s) ; > extern int fputs (__const char *__restrict __s, FILE *__restrict __stream) > ; > extern int puts (__const char *__s) ; > extern int ungetc (int __c, FILE *__stream) ; > extern size_t fread (void *__restrict __ptr, size_t __size, > size_t __n, FILE *__restrict __stream) ; > extern size_t fwrite (__const void *__restrict __ptr, size_t __size, > size_t __n, FILE *__restrict __s) ; > extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, > size_t __n, FILE *__restrict __stream) ; > extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size, > size_t __n, FILE *__restrict __stream) ; > extern int fseek (FILE *__stream, long int __off, int __whence) ; > extern long int ftell (FILE *__stream) ; > extern void rewind (FILE *__stream) ; > extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) > ; > extern int fsetpos (FILE *__stream, __const fpos_t *__pos) ; > extern void clearerr (FILE *__stream) ; > extern int feof (FILE *__stream) ; > extern int ferror (FILE *__stream) ; > extern void clearerr_unlocked (FILE *__stream) ; > extern int feof_unlocked (FILE *__stream) ; > extern int ferror_unlocked (FILE *__stream) ; > extern void perror (__const char *__s) ; > extern int sys_nerr; > extern __const char *__const sys_errlist[]; > extern int fileno (FILE *__stream) ; > extern int fileno_unlocked (FILE *__stream) ; > extern FILE *popen (__const char *__command, __const char *__modes) ; > extern int pclose (FILE *__stream) ; > extern char *ctermid (char *__s) ; > extern void flockfile (FILE *__stream) ; > extern int ftrylockfile (FILE *__stream) ; > extern void funlockfile (FILE *__stream) ; > extern __inline int > vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg) > { > return vfprintf (stdout, __fmt, __arg); > } > extern __inline int > getchar (void) > { > return _IO_getc (stdin); > } > extern __inline int > getc_unlocked (FILE *__fp) > { > return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); > } > extern __inline int > getchar_unlocked (void) > { > return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); > } > extern __inline int > putchar (int __c) > { > return _IO_putc (__c, stdout); > } > extern __inline int > fputc_unlocked (int __c, FILE *__stream) > { > return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); > } > extern __inline int > putc_unlocked (int __c, FILE *__stream) > { > return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); > } > extern __inline int > putchar_unlocked (int __c) > { > return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); > } > extern __inline int > feof_unlocked (FILE *__stream) > { > return (((__stream)->_flags & 0x10) != 0); > } > extern __inline int > ferror_unlocked (FILE *__stream) > { > return (((__stream)->_flags & 0x20) != 0); > } > typedef __gnuc_va_list va_list; > struct objc_method_description > { > SEL name; > char *types; > }; > extern void objc_error (id object, int code, const char* fmt, ...); > extern void objc_verror (id object, int code, const char* fmt, va_list ap); > typedef BOOL (*objc_error_handler) (id, int code, const char *fmt, va_list ap); > objc_error_handler objc_set_error_handler (objc_error_handler func); > struct objc_static_instances > { > char *class_name; > id instances[0]; > }; > typedef struct objc_symtab { > unsigned long sel_ref_cnt; > SEL refs; > unsigned short cls_def_cnt; > unsigned short cat_def_cnt; > void *defs[1]; > } Symtab, *Symtab_t; > typedef struct objc_module { > unsigned long version; > unsigned long size; > const char* name; > Symtab_t symtab; > } Module, *Module_t; > typedef struct objc_ivar* Ivar_t; > typedef struct objc_ivar_list { > int ivar_count; > struct objc_ivar { > const char* ivar_name; > const char* ivar_type; > int ivar_offset; > } ivar_list[1]; > } IvarList, *IvarList_t; > struct objc_method { > SEL method_name; > const char* method_types; > IMP method_imp; > }; > typedef struct objc_method Method; > typedef Method* Method_t; > typedef struct objc_method_list { > struct objc_method_list* method_next; > int method_count; > struct objc_method method_list[1]; > } MethodList, *MethodList_t; > struct objc_protocol_list { > struct objc_protocol_list *next; > int count; > Protocol *list[1]; > }; > typedef struct objc_category { > const char* category_name; > const char* class_name; > MethodList_t instance_methods; > MethodList_t class_methods; > struct objc_protocol_list *protocols; > } Category, *Category_t; > typedef struct objc_super { > id self; > Class class; > } Super, *Super_t; > IMP objc_msg_lookup_super(Super_t super, SEL sel); > retval_t objc_msg_sendv(id, SEL, arglist_t); > extern Class (*_objc_lookup_class) (const char *name); > extern void (*_objc_load_callback) (Class class, Category* category); > extern id (*_objc_object_alloc) (Class class); > extern id (*_objc_object_copy) (id object); > extern id (*_objc_object_dispose) (id object); > void *objc_malloc (size_t size); > void *objc_atomic_malloc (size_t size); > void *objc_valloc (size_t size); > void *objc_realloc (void *mem, size_t size); > void *objc_calloc (size_t nelem, size_t size); > void objc_free (void *mem); > extern void *(*_objc_malloc) (size_t); > extern void *(*_objc_atomic_malloc) (size_t); > extern void *(*_objc_valloc) (size_t); > extern void *(*_objc_realloc) (void *, size_t); > extern void *(*_objc_calloc) (size_t, size_t); > extern void (*_objc_free) (void *); > Method_t class_get_class_method (MetaClass class, SEL aSel); > Method_t class_get_instance_method (Class class, SEL aSel); > Class class_pose_as (Class impostor, Class superclass); > Class objc_get_class (const char *name); > Class objc_lookup_class (const char *name); > Class objc_next_class (void **enum_state); > const char *sel_get_name (SEL selector); > const char *sel_get_type (SEL selector); > SEL sel_get_uid (const char *name); > SEL sel_get_any_uid (const char *name); > SEL sel_get_any_typed_uid (const char *name); > SEL sel_get_typed_uid (const char *name, const char*); > SEL sel_register_name (const char *name); > SEL sel_register_typed_name (const char *name, const char*type); > BOOL sel_is_mapped (SEL aSel); > extern id class_create_instance (Class class); > static inline const char * > class_get_class_name (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L))?class->name:((class==(Class)0)?"Nil":0); > } > static inline long > class_get_instance_size (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)) ? class->instance_size : 0; > } > static inline MetaClass > class_get_meta_class (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)) ? class->class_pointer : (Class)0; > } > static inline Class > class_get_super_class (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)) ? class->super_class : (Class)0; > } > static inline int > class_get_version (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)) ? class->version : -1; > } > static inline BOOL > class_is_class (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)); > } > static inline BOOL > class_is_meta_class (Class class) > { > return ((class)&&((((class)->info) & 0x2L) == 0x2L)); > } > static inline void > class_set_version (Class class, long version) > { > if (((class)&&((((class)->info) & 0x1L) == 0x1L))) > class->version = version; > } > static inline void * > class_get_gc_object_type (Class class) > { > return ((class)&&((((class)->info) & 0x1L) == 0x1L)) ? class->gc_object_type : ((void *)0); > } > extern void class_ivar_set_gcinvisible (Class class, > const char* ivarname, > BOOL gcInvisible); > static inline IMP > method_get_imp (Method_t method) > { > return (method != (Method_t)0) ? method->method_imp : (IMP) 0; > } > IMP get_imp (Class class, SEL sel); > id object_copy (id object); > id object_dispose (id object); > static inline Class > object_get_class (id object) > { > return ((object != (id)0) > ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L)) > ? object->class_pointer > : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L)) > ? (Class) object > : (Class)0)) > : (Class)0); > } > static inline const char * > object_get_class_name (id object) > { > return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L)) > ? object->class_pointer->name > : ((Class) object)->name) > :"Nil"); > } > static inline MetaClass > object_get_meta_class(id object) > { > return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L)) > ? object->class_pointer->class_pointer > : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L)) > ? object->class_pointer > :(Class)0)) > : (Class)0); > } > static inline Class > object_get_super_class (id object) > { > return ((object!=(id)0) ? (((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L)) > ? object->class_pointer->super_class > : (((object->class_pointer)&&((((object->class_pointer)->info) & 0x2L) == 0x2L)) > ?((Class) object)->super_class > : (Class)0)) > : (Class)0); > } > static inline BOOL > object_is_class (id object) > { > return (((Class) object)&&(((((Class) object)->info) & 0x1L) == 0x1L)); > } > static inline BOOL > object_is_instance(id object) > { > return (object != (id)0) && ((object->class_pointer)&&((((object->class_pointer)->info) & 0x1L) == 0x1L)); > } > static inline BOOL > object_is_meta_class (id object) > { > return (((Class) object)&&(((((Class) object)->info) & 0x2L) == 0x2L)); > } > struct sarray* objc_get_uninstalled_dtable (void); > BOOL sel_types_match (const char* t1, const char* t2); > typedef struct > { > int quot; > int rem; > } div_t; > typedef struct > { > long int quot; > long int rem; > } ldiv_t; > extern size_t __ctype_get_mb_cur_max (void) ; > extern double atof (__const char *__nptr) __attribute__ ((__pure__)); > extern int atoi (__const char *__nptr) __attribute__ ((__pure__)); > extern long int atol (__const char *__nptr) __attribute__ ((__pure__)); > __extension__ extern long long int atoll (__const char *__nptr) > __attribute__ ((__pure__)); > extern double strtod (__const char *__restrict __nptr, > char **__restrict __endptr) ; > extern long int strtol (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) ; > extern unsigned long int strtoul (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) > ; > __extension__ > extern long long int strtoq (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) ; > __extension__ > extern unsigned long long int strtouq (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) > ; > __extension__ > extern long long int strtoll (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) ; > __extension__ > extern unsigned long long int strtoull (__const char *__restrict __nptr, > char **__restrict __endptr, int __base) > ; > extern double __strtod_internal (__const char *__restrict __nptr, > char **__restrict __endptr, int __group) > ; > extern float __strtof_internal (__const char *__restrict __nptr, > char **__restrict __endptr, int __group) > ; > extern long double __strtold_internal (__const char *__restrict __nptr, > char **__restrict __endptr, > int __group) ; > extern long int __strtol_internal (__const char *__restrict __nptr, > char **__restrict __endptr, > int __base, int __group) ; > extern unsigned long int __strtoul_internal (__const char *__restrict __nptr, > char **__restrict __endptr, > int __base, int __group) ; > __extension__ > extern long long int __strtoll_internal (__const char *__restrict __nptr, > char **__restrict __endptr, > int __base, int __group) ; > __extension__ > extern unsigned long long int __strtoull_internal (__const char * > __restrict __nptr, > char **__restrict __endptr, > int __base, int __group) > ; > extern __inline double > strtod (__const char *__restrict __nptr, char **__restrict __endptr) > { > return __strtod_internal (__nptr, __endptr, 0); > } > extern __inline long int > strtol (__const char *__restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtol_internal (__nptr, __endptr, __base, 0); > } > extern __inline unsigned long int > strtoul (__const char *__restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtoul_internal (__nptr, __endptr, __base, 0); > } > __extension__ extern __inline long long int > strtoq (__const char *__restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtoll_internal (__nptr, __endptr, __base, 0); > } > __extension__ extern __inline unsigned long long int > strtouq (__const char *__restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtoull_internal (__nptr, __endptr, __base, 0); > } > __extension__ extern __inline long long int > strtoll (__const char *__restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtoll_internal (__nptr, __endptr, __base, 0); > } > __extension__ extern __inline unsigned long long int > strtoull (__const char * __restrict __nptr, char **__restrict __endptr, > int __base) > { > return __strtoull_internal (__nptr, __endptr, __base, 0); > } > extern __inline double > atof (__const char *__nptr) > { > return strtod (__nptr, (char **) ((void *)0)); > } > extern __inline int > atoi (__const char *__nptr) > { > return (int) strtol (__nptr, (char **) ((void *)0), 10); > } > extern __inline long int > atol (__const char *__nptr) > { > return strtol (__nptr, (char **) ((void *)0), 10); > } > __extension__ extern __inline long long int > atoll (__const char *__nptr) > { > return strtoll (__nptr, (char **) ((void *)0), 10); > } > extern char *l64a (long int __n) ; > extern long int a64l (__const char *__s) __attribute__ ((__pure__)); > typedef __u_char u_char; > typedef __u_short u_short; > typedef __u_int u_int; > typedef __u_long u_long; > typedef __quad_t quad_t; > typedef __u_quad_t u_quad_t; > typedef __fsid_t fsid_t; > typedef __loff_t loff_t; > typedef __ino_t ino_t; > typedef __dev_t dev_t; > typedef __gid_t gid_t; > typedef __mode_t mode_t; > typedef __nlink_t nlink_t; > typedef __uid_t uid_t; > typedef __off_t off_t; > typedef __pid_t pid_t; > typedef __id_t id_t; > typedef __ssize_t ssize_t; > typedef __daddr_t daddr_t; > typedef __caddr_t caddr_t; > typedef __key_t key_t; > typedef __time_t time_t; > typedef __clockid_t clockid_t; > typedef __timer_t timer_t; > typedef unsigned long int ulong; > typedef unsigned short int ushort; > typedef unsigned int uint; > typedef int int8_t __attribute__ ((__mode__ (__QI__))); > typedef int int16_t __attribute__ ((__mode__ (__HI__))); > typedef int int32_t __attribute__ ((__mode__ (__SI__))); > typedef int int64_t __attribute__ ((__mode__ (__DI__))); > typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); > typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); > typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); > typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); > typedef int register_t __attribute__ ((__mode__ (__word__))); > typedef int __sig_atomic_t; > typedef struct > { > unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; > } __sigset_t; > typedef __sigset_t sigset_t; > struct timespec > { > long int tv_sec; > long int tv_nsec; > }; > struct timeval > { > __time_t tv_sec; > __suseconds_t tv_usec; > }; > typedef long int __fd_mask; > typedef struct > { > __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))]; > } fd_set; > typedef __fd_mask fd_mask; > extern int select (int __nfds, fd_set *__restrict __readfds, > fd_set *__restrict __writefds, > fd_set *__restrict __exceptfds, > struct timeval *__restrict __timeout) ; > typedef __blkcnt_t blkcnt_t; > typedef __fsblkcnt_t fsblkcnt_t; > typedef __fsfilcnt_t fsfilcnt_t; > extern long int random (void) ; > extern void srandom (unsigned int __seed) ; > extern char *initstate (unsigned int __seed, char *__statebuf, > size_t __statelen) ; > extern char *setstate (char *__statebuf) ; > struct random_data > { > int32_t *fptr; > int32_t *rptr; > int32_t *state; > int rand_type; > int rand_deg; > int rand_sep; > int32_t *end_ptr; > }; > extern int random_r (struct random_data *__restrict __buf, > int32_t *__restrict __result) ; > extern int srandom_r (unsigned int __seed, struct random_data *__buf) ; > extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, > size_t __statelen, > struct random_data *__restrict __buf) ; > extern int setstate_r (char *__restrict __statebuf, > struct random_data *__restrict __buf) ; > extern int rand (void) ; > extern void srand (unsigned int __seed) ; > extern int rand_r (unsigned int *__seed) ; > extern double drand48 (void) ; > extern double erand48 (unsigned short int __xsubi[3]) ; > extern long int lrand48 (void) ; > extern long int nrand48 (unsigned short int __xsubi[3]) ; > extern long int mrand48 (void) ; > extern long int jrand48 (unsigned short int __xsubi[3]) ; > extern void srand48 (long int __seedval) ; > extern unsigned short int *seed48 (unsigned short int __seed16v[3]) ; > extern void lcong48 (unsigned short int __param[7]) ; > struct drand48_data > { > unsigned short int __x[3]; > unsigned short int __old_x[3]; > unsigned short int __c; > unsigned short int __init; > unsigned long long int __a; > }; > extern int drand48_r (struct drand48_data *__restrict __buffer, > double *__restrict __result) ; > extern int erand48_r (unsigned short int __xsubi[3], > struct drand48_data *__restrict __buffer, > double *__restrict __result) ; > extern int lrand48_r (struct drand48_data *__restrict __buffer, > long int *__restrict __result) ; > extern int nrand48_r (unsigned short int __xsubi[3], > struct drand48_data *__restrict __buffer, > long int *__restrict __result) ; > extern int mrand48_r (struct drand48_data *__restrict __buffer, > long int *__restrict __result) ; > extern int jrand48_r (unsigned short int __xsubi[3], > struct drand48_data *__restrict __buffer, > long int *__restrict __result) ; > extern int srand48_r (long int __seedval, struct drand48_data *__buffer) > ; > extern int seed48_r (unsigned short int __seed16v[3], > struct drand48_data *__buffer) ; > extern int lcong48_r (unsigned short int __param[7], > struct drand48_data *__buffer) ; > extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__malloc__)); > extern void free (void *__ptr) ; > extern void cfree (void *__ptr) ; > extern void *alloca (size_t __size) ; > extern void *valloc (size_t __size) __attribute__ ((__malloc__)); > extern void abort (void) __attribute__ ((__noreturn__)); > extern int atexit (void (*__func) (void)) ; > extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) > ; > extern void exit (int __status) __attribute__ ((__noreturn__)); > extern char *getenv (__const char *__name) ; > extern char *__secure_getenv (__const char *__name) ; > extern int putenv (char *__string) ; > extern int setenv (__const char *__name, __const char *__value, int __replace) > ; > extern int unsetenv (__const char *__name) ; > extern int clearenv (void) ; > extern char *mktemp (char *__template) ; > extern int mkstemp (char *__template) ; > extern char *mkdtemp (char *__template) ; > extern int system (__const char *__command) ; > extern char *realpath (__const char *__restrict __name, > char *__restrict __resolved) ; > typedef int (*__compar_fn_t) (__const void *, __const void *); > extern void *bsearch (__const void *__key, __const void *__base, > size_t __nmemb, size_t __size, __compar_fn_t __compar); > extern void qsort (void *__base, size_t __nmemb, size_t __size, > __compar_fn_t __compar); > extern int abs (int __x) __attribute__ ((__const__)); > extern long int labs (long int __x) __attribute__ ((__const__)); > extern div_t div (int __numer, int __denom) > __attribute__ ((__const__)); > extern ldiv_t ldiv (long int __numer, long int __denom) > __attribute__ ((__const__)); > extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, > int *__restrict __sign) ; > extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, > int *__restrict __sign) ; > extern char *gcvt (double __value, int __ndigit, char *__buf) ; > extern char *qecvt (long double __value, int __ndigit, > int *__restrict __decpt, int *__restrict __sign) ; > extern char *qfcvt (long double __value, int __ndigit, > int *__restrict __decpt, int *__restrict __sign) ; > extern char *qgcvt (long double __value, int __ndigit, char *__buf) ; > extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, > int *__restrict __sign, char *__restrict __buf, > size_t __len) ; > extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, > int *__restrict __sign, char *__restrict __buf, > size_t __len) ; > extern int qecvt_r (long double __value, int __ndigit, > int *__restrict __decpt, int *__restrict __sign, > char *__restrict __buf, size_t __len) ; > extern int qfcvt_r (long double __value, int __ndigit, > int *__restrict __decpt, int *__restrict __sign, > char *__restrict __buf, size_t __len) ; > extern int mblen (__const char *__s, size_t __n) ; > extern int mbtowc (wchar_t *__restrict __pwc, > __const char *__restrict __s, size_t __n) ; > extern int wctomb (char *__s, wchar_t __wchar) ; > extern size_t mbstowcs (wchar_t *__restrict __pwcs, > __const char *__restrict __s, size_t __n) ; > extern size_t wcstombs (char *__restrict __s, > __const wchar_t *__restrict __pwcs, size_t __n) > ; > extern int rpmatch (__const char *__response) ; > extern int getloadavg (double __loadavg[], int __nelem) ; > typedef struct { > int offset; > unsigned size; > const char *type; > unsigned align; > unsigned qual; > BOOL isReg; > } NSArgumentInfo; > int objc_aligned_size (const char* type); > int objc_sizeof_type (const char* type); > int objc_alignof_type (const char* type); > int objc_aligned_size (const char* type); > int objc_promoted_size (const char* type); > const char* objc_skip_type_qualifiers (const char* type); > const char* objc_skip_typespec (const char* type); > const char* objc_skip_offset (const char* type); > const char* objc_skip_argspec (const char* type); > int method_get_number_of_arguments (struct objc_method*); > int method_get_sizeof_arguments (struct objc_method*); > char* method_get_first_argument (struct objc_method*, > arglist_t argframe, > const char** type); > char* method_get_next_argument (arglist_t argframe, > const char **type); > char* method_get_nth_argument (struct objc_method* m, > arglist_t argframe, > int arg, > const char **type); > unsigned objc_get_type_qualifiers (const char* type); > struct objc_struct_layout > { > const char *original_type; > const char *type; > const char *prev_type; > unsigned int record_size; > unsigned int record_align; > }; > void objc_layout_structure (const char *type, > struct objc_struct_layout *layout); > BOOL objc_layout_structure_next_member (struct objc_struct_layout *layout); > void objc_layout_finish_structure (struct objc_struct_layout *layout, > unsigned int *size, > unsigned int *align); > void objc_layout_structure_get_info (struct objc_struct_layout *layout, > unsigned int *offset, > unsigned int *align, > const char **type); > extern const char* __objc_sparse2_id; > extern int nbuckets; > extern int nindices; > extern int narrays; > extern int idxsize; > extern void __assert_fail (__const char *__assertion, __const char *__file, > unsigned int __line, __const char *__function) > __attribute__ ((__noreturn__)); > extern void __assert_perror_fail (int __errnum, __const char *__file, > unsigned int __line, > __const char *__function) > __attribute__ ((__noreturn__)); > extern void __assert (const char *__assertion, const char *__file, int __line) > __attribute__ ((__noreturn__)); > typedef size_t sidx; > struct soffset { > unsigned int boffset : (sizeof(size_t)*8)/2; > unsigned int eoffset : (sizeof(size_t)*8)/2; > }; > union sofftype { > struct soffset off; > sidx idx; > }; > union sversion { > int version; > void *next_free; > }; > struct sbucket { > void* elems[(1<<5)]; > union sversion version; > }; > struct sarray { > struct sbucket** buckets; > struct sbucket* empty_bucket; > union sversion version; > short ref_count; > struct sarray* is_copy_of; > size_t capacity; > }; > struct sarray* sarray_new(int, void* default_element); > void sarray_free(struct sarray*); > struct sarray* sarray_lazy_copy(struct sarray*); > void sarray_realloc(struct sarray*, int new_size); > void sarray_at_put(struct sarray*, sidx index, void* elem); > void sarray_at_put_safe(struct sarray*, sidx index, void* elem); > struct sarray* sarray_hard_copy(struct sarray*); > void sarray_remove_garbage(void); > static inline unsigned int > soffset_decode(sidx index) > { > union sofftype x; > x.idx = index; > return x.off.eoffset + (x.off.boffset*(1<<5)); > } > static inline sidx > soffset_encode(size_t offset) > { > union sofftype x; > x.off.eoffset = offset%(1<<5); > x.off.boffset = offset/(1<<5); > return (sidx)x.idx; > } > static inline void* sarray_get(struct sarray* array, sidx index) > { > union sofftype x; > x.idx = index; > return array->buckets[x.off.boffset]->elems[x.off.eoffset]; > } > static inline void* sarray_get_safe(struct sarray* array, sidx index) > { > if(soffset_decode(index) < array->capacity) > return sarray_get(array, index); > else > return (array->empty_bucket->elems[0]); > } > BOOL > mframe_dissect_call (arglist_t argframe, const char *types, > void (*encoder)(int,void*,const char*,int)); > BOOL > mframe_dissect_call_opts (arglist_t argframe, const char *types, > void (*encoder)(int,void*,const char*,int), > BOOL pass_pointers); > void > mframe_do_call (const char *encoded_types, > void(*decoder)(int,void*,const char*), > void(*encoder)(int,void*,const char*,int)); > void > mframe_do_call_opts (const char *encoded_types, > void(*decoder)(int,void*,const char*), > void(*encoder)(int,void*,const char*,int), > BOOL pass_pointers); > retval_t > mframe_build_return (arglist_t argframe, const char *types, > BOOL out_parameters, > void(*decoder)(int,void*,const char*,int)); > retval_t > mframe_build_return_opts (arglist_t argframe, const char *types, > BOOL out_parameters, > void(*decoder)(int,void*,const char*,int), > BOOL pass_pointers); > BOOL > mframe_decode_return(const char *type, void* buffer, void* retframe); > void* > mframe_handle_return(const char* type, void* retval, arglist_t argFrame); > const char * > mframe_next_arg(const char *typePtr, NSArgumentInfo *info); > char* > mframe_build_signature(const char *typePtr, int *size, int *narg, char *buf); > arglist_t > mframe_create_argframe(const char *types, void** retbuf); > void > mframe_destroy_argframe(const char *types, arglist_t argframe); > inline static void* > mframe_arg_addr(arglist_t argf, NSArgumentInfo *info) > { > int offset = info->offset; > if (info->isReg) > { > return(argf->arg_regs + offset); > } > else > { > return(argf->arg_ptr + offset); > } > } > inline static void > mframe_get_arg(arglist_t argf, NSArgumentInfo *info, void* buffer) > { > memcpy(buffer, mframe_arg_addr(argf, info), info->size); > } > inline static void > mframe_set_arg(arglist_t argf, NSArgumentInfo *info, void* buffer) > { > memcpy(mframe_arg_addr(argf, info), buffer, info->size); > } > inline static void > mframe_cpy_arg(arglist_t dst, arglist_t src, NSArgumentInfo *info) > { > memcpy(mframe_arg_addr(dst, info), mframe_arg_addr(src, info), info->size); > } > void *__builtin_alloca (size_t); > char* > mframe_build_signature(const char *typePtr, int *size, int *narg, char *buf) > { > int cum; > BOOL doMalloc = (BOOL)0; > const char *types; > char *start; > char *dest; > int total = 0; > int count = 0; > if (buf == 0) > { > doMalloc = (BOOL)1; > buf = __builtin_alloca ((strlen(typePtr)+1)*16); > } > types = objc_skip_typespec(typePtr); > (__extension__ (__builtin_constant_p (typePtr) && __builtin_constant_p (types - typePtr) ? (strlen (typePtr) + 1 >= ((size_t) (types - typePtr)) ? (char *) memcpy (buf, typePtr, types - typePtr) : strncpy (buf, typePtr, types - typePtr)) : strncpy (buf, typePtr, types - typePtr))); > buf[types-typePtr] = '\0'; > types = objc_skip_type_qualifiers(typePtr); > ((cum) = (*(types)=='{' || *(types)=='(' || *(types)=='[') ? sizeof(void*) : 0); > types = objc_skip_typespec(types); > if (*types == '+') > { > types++; > } > while (({ char _ch = *types; (_ch >= '0' && _ch <= '9'); })) > types++; > start = &buf[strlen(buf)+10]; > dest = start; > while (types && *types) > { > const char *qual = types; > types = objc_skip_type_qualifiers(types); > while (qual < types) > { > *dest++ = *qual++; > } > ({ const char* type = (types); int align = objc_alignof_type(type); int size = objc_sizeof_type(type); (cum) = ({ typeof((cum)) __v=((cum)); typeof(align) __a=(align); __a*((__v+__a-1)/__a); }); (types) = objc_skip_typespec(type); sprintf((dest), "%.*s%d", (types)-type, type, (cum)); if (*(types) == '+') { (types)++; } while (({ char _ch = *(types); (_ch >= '0' && _ch <= '9'); })) { (types)++; } (dest)=&(dest)[strlen(dest)]; if ((*type=='{'||*type=='('||*type=='[')&&size>2) { (total) = (cum) + ({ t ypeof(size) __v=(size); typeof(align) __a=(align); __a*((__v+__a-1)/__a); }); } else { (total) = (cum) + size; } (cum) += ({ typeof(size) __v=(size); typeof(sizeof(void*)) __a=(sizeof(void*)); __a*((__v+__a-1)/__a); }); }); > count++; > } > *dest = '\0'; > sprintf(&buf[strlen(buf)], "%d", total); > dest = &buf[strlen(buf)]; > while (*start) > { > *dest++ = *start++; > } > *dest = '\0'; > if (doMalloc) > { > char *tmp = objc_malloc(dest - buf + 1); > (__extension__ (__builtin_constant_p (buf) ? (((size_t)(const void *)((buf) + 1) - (size_t)(const void *)(buf) == 1) && strlen (buf) + 1 <= 8 ? __strcpy_small (tmp, __extension__ (((__const unsigned char *) (__const char *) (buf))[0 + 1] << 8 | ((__const unsigned char *) (__const char *) (buf))[0]), __extension__ (((__const unsigned char *) (__const char *) (buf))[4 + 1] << 8 | ((__const unsigned char *) (__const char *) (buf))[4]), __extension__ (((((__const unsigned char *) (__const char *) (buf) )[0 + 3] << 8 | ((__const unsigned char *) (__const char *) (buf))[0 + 2]) << 8 | ((__const unsigned char *) (__const char *) (buf))[0 + 1]) << 8 | ((__const unsigned char *) (__const char *) (buf))[0]), __extension__ (((((__const unsigned char *) (__const char *) (buf))[4 + 3] << 8 | ((__const unsigned char *) (__const char *) (buf))[4 + 2]) << 8 | ((__const unsigned char *) (__const char *) (buf))[4 + 1]) << 8 | ((__const unsigned char *) (__const char *) (buf))[4]), strl! en! > (buf) + 1) : (char *) memcpy (tmp, buf, strlen (buf) + 1)) : strcpy (tmp, buf))); > buf = tmp; > } > if (size) > { > *size = total; > } > if (narg) > { > *narg = count; > } > return buf; > } > const char * > mframe_next_arg(const char *typePtr, NSArgumentInfo *info) > { > NSArgumentInfo local; > BOOL flag; > if (info == 0) > { > info = &local; > } > flag = (BOOL)1; > info->qual = 0; > while (flag) > { > switch (*typePtr) > { > case 'r': info->qual |= 0x01; break; > case 'n': info->qual |= 0x01; break; > case 'N': info->qual |= 0x03; break; > case 'o': info->qual |= 0x02; break; > case 'O': info->qual |= 0x04; break; > case 'R': info->qual |= 0x08; break; > case 'V': info->qual |= 0x10; break; > default: flag = (BOOL)0; > } > if (flag) > { > typePtr++; > } > } > info->type = typePtr; > switch (*typePtr++) > { > case '@': > info->size = sizeof(id); > info->align = __alignof__(id); > break; > case '#': > info->size = sizeof(Class); > info->align = __alignof__(Class); > break; > case ':': > info->size = sizeof(SEL); > info->align = __alignof__(SEL); > break; > case 'c': > info->size = sizeof(char); > info->align = __alignof__(char); > break; > case 'C': > info->size = sizeof(unsigned char); > info->align = __alignof__(unsigned char); > break; > case 's': > info->size = sizeof(short); > info->align = __alignof__(short); > break; > case 'S': > info->size = sizeof(unsigned short); > info->align = __alignof__(unsigned short); > break; > case 'i': > info->size = sizeof(int); > info->align = __alignof__(int); > break; > case 'I': > info->size = sizeof(unsigned int); > info->align = __alignof__(unsigned int); > break; > case 'l': > info->size = sizeof(long); > info->align = __alignof__(long); > break; > case 'L': > info->size = sizeof(unsigned long); > info->align = __alignof__(unsigned long); > break; > case 'q': > info->size = sizeof(long long); > info->align = __alignof__(long long); > break; > case 'Q': > info->size = sizeof(unsigned long long); > info->align = __alignof__(unsigned long long); > break; > case 'f': > info->size = sizeof(float); > info->align = __alignof__(float); > break; > case 'd': > info->size = sizeof(double); > info->align = __alignof__(double); > break; > case '^': > info->size = sizeof(char*); > info->align = __alignof__(char*); > if (*typePtr == '?') > { > typePtr++; > } > else > { > typePtr = mframe_next_arg(typePtr, &local); > info->isReg = local.isReg; > info->offset = local.offset; > } > break; > case '%': > case '*': > info->size = sizeof(char*); > info->align = __alignof__(char*); > break; > case '[': > { > int length = atoi(typePtr); > while (({ char _ch = *typePtr; (_ch >= '0' && _ch <= '9'); })) > typePtr++; > typePtr = mframe_next_arg(typePtr, &local); > info->size = length * ({ typeof(local.size) __v=(local.size); typeof(local.align) __a=(local.align); __a*((__v+__a-1)/__a); }); > info->align = local.align; > typePtr++; > } > break; > case '{': > { > struct { int x; double y; } fooalign; > int acc_size = 0; > int acc_align = __alignof__(fooalign); > while (*typePtr != '}') > { > if (*typePtr++ == '=') > { > break; > } > } > if (*typePtr != '}') > { > typePtr = mframe_next_arg(typePtr, &local); > if (typePtr == 0) > { > return 0; > } > acc_size = ({ typeof(acc_size) __v=(acc_size); typeof(local.align) __a=(local.align); __a*((__v+__a-1)/__a); }); > acc_size += local.size; > acc_align = (((local.align)>(__alignof__(fooalign)))?(local.align):(__alignof__(fooalign))); > } > while (*typePtr != '}') > { > typePtr = mframe_next_arg(typePtr, &local); > if (typePtr == 0) > { > return 0; > } > acc_size = ({ typeof(acc_size) __v=(acc_size); typeof(local.align) __a=(local.align); __a*((__v+__a-1)/__a); }); > acc_size += local.size; > } > info->size = acc_size; > info->align = acc_align; > typePtr++; > } > break; > case '(': > { > int max_size = 0; > int max_align = 0; > while (*typePtr != ')') > { > if (*typePtr++ == '=') > { > break; > } > } > while (*typePtr != ')') > { > typePtr = mframe_next_arg(typePtr, &local); > if (typePtr == 0) > { > return 0; > } > max_size = (((max_size)>(local.size))?(max_size):(local.size)); > max_align = (((max_align)>(local.align))?(max_align):(local.align)); > } > info->size = max_size; > info->align = max_align; > typePtr++; > } > break; > case 'v': > info->size = 0; > info->align = __alignof__(char*); > break; > default: > return 0; > } > if (typePtr == 0) > { > return 0; > } > if (info->type[0] != '^' || info->type[1] == '?') > { > BOOL negFlag = (BOOL)0; > if (*typePtr == '-') > { > typePtr++; > negFlag = (BOOL)1; > info->isReg = (BOOL)0; > } > else if (*typePtr == '+') > { > typePtr++; > info->isReg = (BOOL)1; > } > else > info->isReg = (BOOL)0; > info->offset = 0; > while (({ char _ch = *typePtr; (_ch >= '0' && _ch <= '9'); })) > info->offset = info->offset * 10 + (*typePtr++ - '0'); > if (negFlag) > info->offset *= -1; > } > return typePtr; > } > int > method_types_get_number_of_arguments (const char *type) > { > int i = 0; > while (*type) > { > type = objc_skip_argspec (type); > i += 1; > } > return i - 1; > } > int > method_types_get_size_of_stack_arguments (const char *type) > { > type = objc_skip_typespec (type); > return atoi (type); > } > int > method_types_get_size_of_register_arguments(const char *types) > { > const char* type = strrchr(types, '+'); > if (type) > { > return atoi(++type) + sizeof(void*); > } > else > { > return 0; > } > } > char* > method_types_get_next_argument (arglist_t argf, const char **type) > { > const char *t = objc_skip_argspec (*type); > arglist_t argframe; > argframe = (void*)argf; > if (*t == '\0') > { > return 0; > } > *type = t; > t = objc_skip_typespec (t); > if (*t == '+') > { > return argframe->arg_regs + atoi(++t); > } > else > { > return argframe->arg_ptr + atoi(t); > } > } > BOOL > mframe_dissect_call_opts (arglist_t argframe, const char *type, > void (*encoder)(int,void*,const char*,int), > BOOL pass_pointers) > { > unsigned flags; > char *datum; > int argnum; > BOOL out_parameters = (BOOL)0; > if (*type == '{' || *type == '(' || *type == '[') { > datum = __builtin_alloca ((strlen(type)+1)*10); > type = mframe_build_signature(type, 0, 0, datum); > } > for (datum = method_types_get_next_argument(argframe, &type), argnum=0; > datum; > datum = method_types_get_next_argument(argframe, &type), argnum++) > { > flags = objc_get_type_qualifiers(type); > type = objc_skip_type_qualifiers(type); > switch (*type) > { > case '*': > if ((flags & 0x02) || !(flags & 0x01)) > out_parameters = (BOOL)1; > if ((flags & 0x01) || !(flags & 0x02)) > (*encoder) (argnum, datum, type, flags); > break; > case '^': > if ((flags & 0x02) || !(flags & 0x01)) > out_parameters = (BOOL)1; > if (pass_pointers) { > if ((flags & 0x01) || !(flags & 0x02)) > (*encoder) (argnum, datum, type, flags); > } > else { > type++; > if ((flags & 0x01) || !(flags & 0x02)) > (*encoder) (argnum, *(void**)datum, type, flags); > } > break; > case '{': > case '(': > case '[': > (*encoder) (argnum, datum, type, flags); > break; > default: > (*encoder) (argnum, datum, type, flags); > } > } > return out_parameters; > } > BOOL > mframe_dissect_call (arglist_t argframe, const char *type, > void (*encoder)(int,void*,const char*,int)) > { > return mframe_dissect_call_opts(argframe, type, encoder, (BOOL)0); > } > void > mframe_do_call_opts (const char *encoded_types, > void(*decoder)(int,void*,const char*), > void(*encoder)(int,void*,const char*,int), > BOOL pass_pointers) > { > const char *type; > const char *tmptype; > const char *etmptype; > id object; > SEL selector; > IMP method_implementation; > int stack_argsize; > int reg_argsize; > arglist_t argframe; > char *datum; > unsigned flags; > int argnum; > void *retframe; > BOOL out_parameters = (BOOL)0; > float retframe_float (void *rframe) > { > __builtin_return (rframe); > } > double retframe_double (void *rframe) > { > __builtin_return (rframe); > } > char retframe_char (void *rframe) > { > __builtin_return (rframe); > } > short retframe_short (void *rframe) > { > __builtin_return (rframe); > } > (*decoder) (0, &object, @encode(id)); > ((void) ((object) ? 0 : (__assert_fail ("object", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 824, __PRETTY_FUNCTION__), 0))); > (*decoder) (1, &selector, ":"); > ((void) ((selector) ? 0 : (__assert_fail ("selector", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 830, __PRETTY_FUNCTION__), 0))); > type = sel_get_type (selector); > ((void) ((type) ? 0 : (__assert_fail ("type", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 862, __PRETTY_FUNCTION__), 0))); > ((void) ((sel_types_match(encoded_types, type)) ? 0 : (__assert_fail ("sel_types_match(encoded_types, type)", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 863, __PRETTY_FUNCTION__), 0))); > if (*type == '{' || *type == '(' || *type == '[') { > tmptype = __builtin_alloca ((strlen(type)+1)*10); > type = mframe_build_signature(type, 0, 0, (char*)tmptype); > } > stack_argsize = method_types_get_size_of_stack_arguments (type); > reg_argsize = method_types_get_size_of_register_arguments (type); > argframe = (arglist_t) __builtin_alloca (sizeof(char*) + reg_argsize); > if (stack_argsize) > argframe->arg_ptr = __builtin_alloca (stack_argsize); > else > argframe->arg_ptr = 0; > if (*type == '{' || *type == '(' || *type == '[') > { > void *buf; > buf = __builtin_alloca (objc_sizeof_type(type)); > ({if (*(type)=='{' || *(type)=='(' || *(type)=='[') *(void**)(argframe)->arg_ptr = (buf);}); > } > tmptype = type; > etmptype = objc_skip_argspec (encoded_types); > datum = method_types_get_next_argument (argframe, &tmptype); > ((void) ((datum) ? 0 : (__assert_fail ("datum", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 908, __PRETTY_FUNCTION__), 0))); > ((void) ((*tmptype == '@') ? 0 : (__assert_fail ("*tmptype == '@'", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 909, __PRETTY_FUNCTION__), 0))); > *(id*)datum = object; > etmptype = objc_skip_argspec(etmptype); > datum = method_types_get_next_argument(argframe, &tmptype); > ((void) ((datum) ? 0 : (__assert_fail ("datum", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 916, __PRETTY_FUNCTION__), 0))); > ((void) ((*tmptype == ':') ? 0 : (__assert_fail ("*tmptype == ':'", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 917, __PRETTY_FUNCTION__), 0))); > *(SEL*)datum = selector; > for (datum = method_types_get_next_argument (argframe, &tmptype), > etmptype = objc_skip_argspec (etmptype), argnum = 2; > datum; > datum = method_types_get_next_argument (argframe, &tmptype), > etmptype = objc_skip_argspec (etmptype), argnum++) > { > flags = objc_get_type_qualifiers (etmptype); > tmptype = objc_skip_type_qualifiers(tmptype); > switch (*tmptype) > { > case '*': > if ((flags & 0x02) || !(flags & 0x01)) > out_parameters = (BOOL)1; > if ((flags & 0x01) || !(flags & 0x02)) > (*decoder) (argnum, datum, tmptype); > break; > case '^': > if ((flags & 0x02) || !(flags & 0x01)) > out_parameters = (BOOL)1; > if (pass_pointers) > { > if ((flags & 0x01) || !(flags & 0x02)) > (*decoder) (argnum, datum, tmptype); > } > else > { > tmptype++; > *(void**)datum = __builtin_alloca (objc_sizeof_type (tmptype)); > if ((flags & 0x01) || !(flags & 0x02)) > (*decoder) (argnum, *(void**)datum, tmptype); > } > break; > case '{': > case '(': > case '[': > (*decoder) (argnum, datum, tmptype); > break; > default: > (*decoder) (argnum, datum, tmptype); > } > } > (*decoder) (-1, 0, 0); > method_implementation = objc_msg_lookup (object, selector); > ((void) ((method_implementation) ? 0 : (__assert_fail ("method_implementation", "/home/swarm/swarm-2001-06-06/libobjc/mframe.m", 1041, __PRETTY_FUNCTION__), 0))); > retframe = __builtin_apply((void(*)(void))method_implementation, > argframe, > stack_argsize); > flags = objc_get_type_qualifiers (encoded_types); > etmptype = objc_skip_type_qualifiers (encoded_types); > tmptype = objc_skip_type_qualifiers (type); > switch (*tmptype) > { > case 'v': > if ((flags & 0x10) == 0) > { > int dummy = 0; > (*encoder) (-1, (void*)&dummy, @encode(int), 0); > } > break; > case '^': > if (pass_pointers) > { > (*encoder) (-1, retframe, tmptype, flags); > } > else > { > tmptype++; > (*encoder) (-1, *(void**)retframe, tmptype, flags); > } > break; > case '{': > case '(': > case '[': > (*encoder)(-1, ((*(tmptype)=='{' || *(tmptype)=='(' || *(tmptype)=='[') ? *(void**)(argframe)->arg_ptr : (void*)0), tmptype, flags); > break; > case 'f': > { > float ret = retframe_float (retframe); > (*encoder) (-1, &ret, tmptype, flags); > break; > } > case 'd': > { > double ret = retframe_double (retframe); > (*encoder) (-1, &ret, tmptype, flags); > break; > } > case 's': > case 'S': > { > short ret = retframe_short (retframe); > (*encoder) (-1, &ret, tmptype, flags); > break; > } > case 'c': > case 'C': > { > char ret = retframe_char (retframe); > (*encoder) (-1, &ret, tmptype, flags); > break; > } > default: > (*encoder) (-1, retframe, tmptype, flags); > } > if (out_parameters) > { > for (datum = method_types_get_next_argument (argframe, &tmptype), > argnum = 1, > etmptype = objc_skip_argspec (etmptype); > datum; > datum = method_types_get_next_argument (argframe, &tmptype), > argnum++, > etmptype = objc_skip_argspec (etmptype)) > { > flags = objc_get_type_qualifiers(etmptype); > tmptype = objc_skip_type_qualifiers (tmptype); > if ((*tmptype == '^') > && ((flags & 0x02) || !(flags & 0x01))) > { > tmptype++; > (*encoder) (argnum, *(void**)datum, tmptype, flags); > } > else if (*tmptype == '*' > && ((flags & 0x02) || !(flags & 0x01))) > { > (*encoder) (argnum, datum, tmptype, flags); > } > } > } > return; > } > void > mframe_do_call (const char *encoded_types, > void(*decoder)(int,void*,const char*), > void(*encoder)(int,void*,const char*,int)) > { > mframe_do_call_opts(encoded_types, decoder, encoder, (BOOL)0); > } > retval_t > mframe_build_return_opts (arglist_t argframe, > const char *type, > BOOL out_parameters, > void(*decoder)(int,void*,const char*,int), > BOOL pass_pointers) > { > retval_t retframe = ((void *)0); > int retsize; > int argnum; > int flags; > const char *tmptype; > void *datum; > const char *rettype; > typedef struct { id many[8];} __big; > __big return_block (void* data) > { > return *(__big*)data; > } > char return_char (char data) > { > return data; > } > double return_double (double data) > { > return data; > } > float return_float (float data) > { > return data; > } > short return_short (short data) > { > return data; > } > retval_t apply_block(void* data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_block, args, sizeof(void*)); > } > retval_t apply_char(char data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_char, args, sizeof(void*)); > } > retval_t apply_float(float data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_float, args, sizeof(float)); > } > retval_t apply_double(double data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_double, args, sizeof(double)); > } > retval_t apply_short(short data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_short, args, sizeof(void*)); > } > if (*type == '{' || *type == '(' || *type == '[') > { > tmptype = __builtin_alloca ((strlen(type)+1)*10); > type = mframe_build_signature(type, 0, 0, (char*)tmptype); > } > flags = objc_get_type_qualifiers(type); > tmptype = objc_skip_type_qualifiers(type); > rettype = tmptype; > if (out_parameters || *tmptype != 'v' || (flags & 0x10) == 0) > { > if (*tmptype != 'v' || (flags & 0x10) == 0) > { > if (*tmptype == 'v') > retsize = sizeof(void*); > else > retsize = objc_sizeof_type (tmptype); > retframe = __builtin_alloca ((((retsize)>(sizeof(void*)*4))?(retsize):(sizeof(void*)*4))); > switch (*tmptype) > { > case '^': > if (pass_pointers) > { > (*decoder) (-1, retframe, tmptype, flags); > } > else > { > unsigned retLength; > tmptype++; > retLength = objc_sizeof_type(tmptype); > *(void**)retframe = > objc_malloc (retLength); > (*decoder) (-1, *(void**)retframe, tmptype, flags); > } > break; > case '{': > case '(': > case '[': > *(void**)retframe = ((*(tmptype)=='{' || *(tmptype)=='(' || *(tmptype)=='[') ? *(void**)(argframe)->arg_ptr : (void*)0); > (*decoder) (-1, *(void**)retframe, tmptype, flags); > break; > case 'f': > case 'd': > (*decoder) (-1, ((char*)retframe), tmptype, flags); > break; > case 'v': > { > (*decoder) (-1, retframe, @encode(int), 0); > } > break; > default: > if (retsize < sizeof(void*)) > { > (*decoder) (-1, retframe, tmptype, flags); > } > else > { > (*decoder) (-1, retframe, tmptype, flags); > } > } > } > if (out_parameters) > { > for (datum = method_types_get_next_argument(argframe, &tmptype), > argnum=0; > datum; > (datum = method_types_get_next_argument(argframe, &tmptype)), > argnum++) > { > flags = objc_get_type_qualifiers(tmptype); > tmptype = objc_skip_type_qualifiers(tmptype); > if (*tmptype == '^' > && ((flags & 0x02) || !(flags & 0x01))) > { > tmptype++; > (*decoder) (argnum, *(void**)datum, tmptype, flags); > } > else if (*tmptype == '*' > && ((flags & 0x02) || !(flags & 0x01))) > { > (*decoder) (argnum, datum, tmptype, flags); > } > } > } > (*decoder) (0, 0, 0, 0); > } > else > { > retframe = __builtin_alloca (sizeof(void*)); > } > switch (*rettype) { > case 'c': > case 'C': > return apply_char(*(char*)retframe); > case 'd': > return apply_double(*(double*)retframe); > case 'f': > return apply_float(*(float*)retframe); > case 's': > case 'S': > return apply_short(*(short*)retframe); > } > return retframe; > } > retval_t > mframe_build_return (arglist_t argframe, > const char *type, > BOOL out_parameters, > void(*decoder)(int,void*,const char*,int)) > { > return mframe_build_return_opts(argframe,type,out_parameters,decoder,(BOOL)0); > } > arglist_t > mframe_create_argframe(const char *types, void** retbuf) > { > arglist_t argframe = objc_calloc(8, 1); > const char* rtype = objc_skip_type_qualifiers(types); > int stack_argsize = atoi(objc_skip_typespec(rtype)); > if (stack_argsize) > { > argframe->arg_ptr = objc_calloc(stack_argsize, 1); > } > else > { > argframe->arg_ptr = 0; > } > if (*rtype == '{' || *rtype == '(' || *rtype == '[') > { > if (*retbuf == 0) > { > *retbuf = objc_calloc(objc_sizeof_type(rtype), 1); > } > ({if (*(rtype)=='{' || *(rtype)=='(' || *(rtype)=='[') *(void**)(argframe)->arg_ptr = (*retbuf);}); > } > return argframe; > } > void > mframe_destroy_argframe(const char *types, arglist_t argframe) > { > const char* rtype = objc_skip_type_qualifiers(types); > int stack_argsize = atoi(objc_skip_typespec(rtype)); > if (stack_argsize) > { > objc_free(argframe->arg_ptr); > } > objc_free(argframe); > } > static void > getSizeAndAlignment(const char *typePtr, unsigned *sizep, unsigned *alignp) > { > NSArgumentInfo info; > typePtr = mframe_next_arg(typePtr, &info); > if (sizep) > *sizep = info.size; > if (alignp) > *alignp = info.align; > } > BOOL > mframe_decode_return (const char *type, void* buffer, void* retframe) > { > int size = 0; > type = objc_skip_type_qualifiers(type); > getSizeAndAlignment(type, &size, 0); > switch (*type) > { > case '@': > { > inline id retframe_id(void *rframe) > { > __builtin_return (rframe); > } > *(id*)buffer = retframe_id(retframe); > break; > } > case '#': > { > inline Class retframe_Class(void *rframe) > { > __builtin_return (rframe); > } > *(Class*)buffer = retframe_Class(retframe); > break; > } > case ':': > { > inline SEL retframe_SEL(void *rframe) > { > __builtin_return (rframe); > } > *(SEL*)buffer = retframe_SEL(retframe); > break; > } > case 'c': > case 'C': > { > inline unsigned char retframe_char(void *rframe) > { > __builtin_return (rframe); > } > *(unsigned char*)buffer = retframe_char(retframe); > break; > } > case 's': > case 'S': > { > inline unsigned short retframe_short(void *rframe) > { > __builtin_return (rframe); > } > *(unsigned short*)buffer = retframe_short(retframe); > break; > } > case 'i': > case 'I': > { > inline unsigned int retframe_int(void *rframe) > { > __builtin_return (rframe); > } > *(unsigned int*)buffer = retframe_int(retframe); > break; > } > case 'l': > case 'L': > { > inline unsigned long retframe_long(void *rframe) > { > __builtin_return (rframe); > } > *(unsigned long*)buffer = retframe_long(retframe); > break; > } > case 'q': > case 'Q': > { > inline unsigned long long retframe_longlong(void *rframe) > { > __builtin_return (rframe); > } > *(unsigned long long*)buffer = retframe_longlong(retframe); > break; > } > case 'f': > { > inline float retframe_float(void *rframe) > { > __builtin_return (rframe); > } > *(float*)buffer = retframe_float(retframe); > break; > } > case 'd': > { > inline double retframe_double(void *rframe) > { > __builtin_return (rframe); > } > *(double*)buffer = retframe_double(retframe); > break; > } > case '^': > case '%': > case '*': > { > inline char* retframe_pointer(void *rframe) > { > __builtin_return (rframe); > } > *(char**)buffer = retframe_pointer(retframe); > break; > } > case '[': > case '{': > case '(': > { > typedef struct { > char val[size]; > } block; > inline block retframe_block(void *rframe) > { > __builtin_return (rframe); > } > *(block *) buffer = retframe_block (retframe); > break; > } > case 'v': > break; > default: > return (BOOL)0; > } > return (BOOL)1; > } > void* > mframe_handle_return(const char* type, void* retval, arglist_t argframe) > { > retval_t retframe; > typedef struct { id many[8];} __big; > __big return_block (void* data) > { > return *(__big*)data; > } > char return_char (char data) > { > return data; > } > double return_double (double data) > { > return data; > } > float return_float (float data) > { > return data; > } > short return_short (short data) > { > return data; > } > retval_t apply_block(void* data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_block, args, sizeof(void*)); > } > retval_t apply_char(char data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_char, args, sizeof(void*)); > } > retval_t apply_float(float data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_float, args, sizeof(float)); > } > retval_t apply_double(double data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_double, args, sizeof(double)); > } > retval_t apply_short(short data) > { > void* args = __builtin_apply_args(); > return __builtin_apply((apply_t)return_short, args, sizeof(void*)); > } > retframe = __builtin_alloca (116); > switch (*type) > { > case 'v': > break; > case 'c': > case 'C': > return apply_char(*(char*)retval); > case 'd': > return apply_double(*(double*)retval); > case 'f': > return apply_float(*(float*)retval); > case 's': > case 'S': > return apply_short(*(short*)retval); > case '[': > case '(': > case '{': > { > int size = objc_sizeof_type(type); > void *dest; > dest = ((*(type)=='{' || *(type)=='(' || *(type)=='[') ? *(void**)(argframe)->arg_ptr : (void*)0); > memcpy(dest, retval, size); > break; > } > default: > memcpy(retframe, retval, objc_sizeof_type(type)); > break; > } > return retframe; > } > --------------------- File ends ------------------- > End of Report > >Release-Note: > >Audit-Trail: > >Unformatted: > --- Note --- > This is second try; qmail at sourceware gave reject because To: header > was missing, but then I also got a tracking ID of 3019. So, I'm sending > again, just in case. > --- End of note --- > > Synopsis:ICE in compiling a .mi file > Class: ice-on-illegal-code >