romdev-mcp 0.1.1

package/src/platforms/gba/lib/libgba/sysinclude/stdio_ext.h

@@ -0,0 +1,79 @@
+/*
+ * stdio_ext.h
+ *
+ * Definitions for I/O internal operations, originally from Solaris.
+ */
+
+#ifndef _STDIO_EXT_H_
+#define _STDIO_EXT_H_
+
+#ifdef __rtems__
+#error "<stdio_ext.h> not supported"
+#endif
+
+#include <stdio.h>
+
+#define	FSETLOCKING_QUERY	0
+#define	FSETLOCKING_INTERNAL	1
+#define	FSETLOCKING_BYCALLER	2
+
+_BEGIN_STD_C
+
+void	 __fpurge (FILE *);
+int	 __fsetlocking (FILE *, int);
+
+/* TODO:
+
+   void _flushlbf (void);
+*/
+
+#ifdef  __GNUC__
+
+_ELIDABLE_INLINE size_t
+__fbufsize (FILE *__fp) { return (size_t) __fp->_bf._size; }
+
+_ELIDABLE_INLINE int
+__freading (FILE *__fp) { return (__fp->_flags & __SRD) != 0; }
+
+_ELIDABLE_INLINE int
+__fwriting (FILE *__fp) { return (__fp->_flags & __SWR) != 0; }
+
+_ELIDABLE_INLINE int
+__freadable (FILE *__fp) { return (__fp->_flags & (__SRD | __SRW)) != 0; }
+
+_ELIDABLE_INLINE int
+__fwritable (FILE *__fp) { return (__fp->_flags & (__SWR | __SRW)) != 0; }
+
+_ELIDABLE_INLINE int
+__flbf (FILE *__fp) { return (__fp->_flags & __SLBF) != 0; }
+
+_ELIDABLE_INLINE size_t
+__fpending (FILE *__fp) { return __fp->_p - __fp->_bf._base; }
+
+#else
+
+size_t	 __fbufsize (FILE *);
+int	 __freading (FILE *);
+int	 __fwriting (FILE *);
+int	 __freadable (FILE *);
+int	 __fwritable (FILE *);
+int	 __flbf (FILE *);
+size_t	 __fpending (FILE *);
+
+#ifndef __cplusplus
+
+#define __fbufsize(__fp) ((size_t) (__fp)->_bf._size)
+#define __freading(__fp) (((__fp)->_flags & __SRD) != 0)
+#define __fwriting(__fp) (((__fp)->_flags & __SWR) != 0)
+#define __freadable(__fp) (((__fp)->_flags & (__SRD | __SRW)) != 0)
+#define __fwritable(__fp) (((__fp)->_flags & (__SWR | __SRW)) != 0)
+#define __flbf(__fp) (((__fp)->_flags & __SLBF) != 0)
+#define __fpending(__fp) ((size_t) ((__fp)->_p - (__fp)->_bf._base))
+
+#endif /* __cplusplus */
+
+#endif /* __GNUC__ */
+
+_END_STD_C
+
+#endif /* _STDIO_EXT_H_ */

package/src/platforms/gba/lib/libgba/sysinclude/stdlib.h

@@ -0,0 +1,345 @@
+/*
+ * stdlib.h
+ *
+ * Definitions for common types, variables, and functions.
+ */
+
+#ifndef _STDLIB_H_
+#define _STDLIB_H_
+
+#include <machine/ieeefp.h>
+#include "_ansi.h"
+
+#define __need_size_t
+#define __need_wchar_t
+#define __need_NULL
+#include <stddef.h>
+
+#include <sys/reent.h>
+#include <sys/cdefs.h>
+#include <machine/stdlib.h>
+#ifndef __STRICT_ANSI__
+#include <alloca.h>
+#endif
+
+#ifdef __CYGWIN__
+#include <cygwin/stdlib.h>
+#endif
+
+#if __GNU_VISIBLE
+#include <sys/_locale.h>
+#endif
+
+_BEGIN_STD_C
+
+typedef struct 
+{
+  int quot; /* quotient */
+  int rem; /* remainder */
+} div_t;
+
+typedef struct 
+{
+  long quot; /* quotient */
+  long rem; /* remainder */
+} ldiv_t;
+
+#if __ISO_C_VISIBLE >= 1999
+typedef struct
+{
+  long long int quot; /* quotient */
+  long long int rem; /* remainder */
+} lldiv_t;
+#endif
+
+#ifndef __compar_fn_t_defined
+#define __compar_fn_t_defined
+typedef int (*__compar_fn_t) (const void *, const void *);
+#endif
+
+#define EXIT_FAILURE 1
+#define EXIT_SUCCESS 0
+
+#define RAND_MAX __RAND_MAX
+
+int	__locale_mb_cur_max (void);
+
+#define MB_CUR_MAX __locale_mb_cur_max()
+
+void	abort (void) _ATTRIBUTE ((__noreturn__));
+int	abs (int);
+#if __BSD_VISIBLE
+__uint32_t arc4random (void);
+__uint32_t arc4random_uniform (__uint32_t);
+void    arc4random_buf (void *, size_t);
+#endif
+int	atexit (void (*__func)(void));
+double	atof (const char *__nptr);
+#if __MISC_VISIBLE
+float	atoff (const char *__nptr);
+#endif
+int	atoi (const char *__nptr);
+int	_atoi_r (struct _reent *, const char *__nptr);
+long	atol (const char *__nptr);
+long	_atol_r (struct _reent *, const char *__nptr);
+void *	bsearch (const void *__key,
+		       const void *__base,
+		       size_t __nmemb,
+		       size_t __size,
+		       __compar_fn_t _compar);
+void	*calloc(size_t, size_t) __malloc_like __result_use_check
+	     __alloc_size2(1, 2) _NOTHROW;
+div_t	div (int __numer, int __denom);
+void	exit (int __status) _ATTRIBUTE ((__noreturn__));
+void	free (void *) _NOTHROW;
+char *  getenv (const char *__string);
+char *	_getenv_r (struct _reent *, const char *__string);
+#if __GNU_VISIBLE
+char *  secure_getenv (const char *__string);
+#endif
+char *	_findenv (const char *, int *);
+char *	_findenv_r (struct _reent *, const char *, int *);
+#if __POSIX_VISIBLE >= 200809
+extern char *suboptarg;			/* getsubopt(3) external variable */
+int	getsubopt (char **, char * const *, char **);
+#endif
+long	labs (long);
+ldiv_t	ldiv (long __numer, long __denom);
+void	*malloc(size_t) __malloc_like __result_use_check __alloc_size(1) _NOTHROW;
+int	mblen (const char *, size_t);
+int	_mblen_r (struct _reent *, const char *, size_t, _mbstate_t *);
+int	mbtowc (wchar_t *__restrict, const char *__restrict, size_t);
+int	_mbtowc_r (struct _reent *, wchar_t *__restrict, const char *__restrict, size_t, _mbstate_t *);
+int	wctomb (char *, wchar_t);
+int	_wctomb_r (struct _reent *, char *, wchar_t, _mbstate_t *);
+size_t	mbstowcs (wchar_t *__restrict, const char *__restrict, size_t);
+size_t	_mbstowcs_r (struct _reent *, wchar_t *__restrict, const char *__restrict, size_t, _mbstate_t *);
+size_t	wcstombs (char *__restrict, const wchar_t *__restrict, size_t);
+size_t	_wcstombs_r (struct _reent *, char *__restrict, const wchar_t *__restrict, size_t, _mbstate_t *);
+#ifndef _REENT_ONLY
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200809
+char *	mkdtemp (char *);
+#endif
+#if __GNU_VISIBLE
+int	mkostemp (char *, int);
+int	mkostemps (char *, int, int);
+#endif
+#if __MISC_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 4
+int	mkstemp (char *);
+#endif
+#if __MISC_VISIBLE
+int	mkstemps (char *, int);
+#endif
+#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112)
+char *	mktemp (char *) _ATTRIBUTE ((__deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
+#endif
+#endif /* !_REENT_ONLY */
+char *	_mkdtemp_r (struct _reent *, char *);
+int	_mkostemp_r (struct _reent *, char *, int);
+int	_mkostemps_r (struct _reent *, char *, int, int);
+int	_mkstemp_r (struct _reent *, char *);
+int	_mkstemps_r (struct _reent *, char *, int);
+char *	_mktemp_r (struct _reent *, char *) _ATTRIBUTE ((__deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
+void	qsort (void *__base, size_t __nmemb, size_t __size, __compar_fn_t _compar);
+int	rand (void);
+void	*realloc(void *, size_t) __result_use_check __alloc_size(2) _NOTHROW;
+#if __BSD_VISIBLE
+void	*reallocarray(void *, size_t, size_t) __result_use_check __alloc_size2(2, 3);
+void	*reallocf(void *, size_t) __result_use_check __alloc_size(2);
+#endif
+#if __BSD_VISIBLE || __XSI_VISIBLE >= 4
+char *	realpath (const char *__restrict path, char *__restrict resolved_path);
+#endif
+#if __BSD_VISIBLE
+int	rpmatch (const char *response);
+#endif
+#if __XSI_VISIBLE
+void	setkey (const char *__key);
+#endif
+void	srand (unsigned __seed);
+double	strtod (const char *__restrict __n, char **__restrict __end_PTR);
+double	_strtod_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR);
+#if __ISO_C_VISIBLE >= 1999
+float	strtof (const char *__restrict __n, char **__restrict __end_PTR);
+#endif
+#if __MISC_VISIBLE
+/* the following strtodf interface is deprecated...use strtof instead */
+# ifndef strtodf
+#  define strtodf strtof
+# endif
+#endif
+long	strtol (const char *__restrict __n, char **__restrict __end_PTR, int __base);
+long	_strtol_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR, int __base);
+unsigned long strtoul (const char *__restrict __n, char **__restrict __end_PTR, int __base);
+unsigned long _strtoul_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR, int __base);
+
+#if __GNU_VISIBLE
+double	strtod_l (const char *__restrict, char **__restrict, locale_t);
+float	strtof_l (const char *__restrict, char **__restrict, locale_t);
+#ifdef _HAVE_LONG_DOUBLE
+extern long double strtold_l (const char *__restrict, char **__restrict,
+			      locale_t);
+#endif /* _HAVE_LONG_DOUBLE */
+long	strtol_l (const char *__restrict, char **__restrict, int, locale_t);
+unsigned long strtoul_l (const char *__restrict, char **__restrict, int,
+			 locale_t __loc);
+long long strtoll_l (const char *__restrict, char **__restrict, int, locale_t);
+unsigned long long strtoull_l (const char *__restrict, char **__restrict, int,
+			       locale_t __loc);
+#endif
+
+int	system (const char *__string);
+
+#if __SVID_VISIBLE || __XSI_VISIBLE >= 4
+long    a64l (const char *__input);
+char *  l64a (long __input);
+char *  _l64a_r (struct _reent *,long __input);
+#endif
+#if __MISC_VISIBLE
+int	on_exit (void (*__func)(int, void *),void *__arg);
+#endif
+#if __ISO_C_VISIBLE >= 1999
+void	_Exit (int __status) _ATTRIBUTE ((__noreturn__));
+#endif
+#if __SVID_VISIBLE || __XSI_VISIBLE
+int	putenv (char *__string);
+#endif
+int	_putenv_r (struct _reent *, char *__string);
+void *	_reallocf_r (struct _reent *, void *, size_t);
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
+int	setenv (const char *__string, const char *__value, int __overwrite);
+#endif
+int	_setenv_r (struct _reent *, const char *__string, const char *__value, int __overwrite);
+
+#if __XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112
+char *	gcvt (double,int,char *);
+char *	gcvtf (float,int,char *);
+char *	fcvt (double,int,int *,int *);
+char *	fcvtf (float,int,int *,int *);
+char *	ecvt (double,int,int *,int *);
+char *	ecvtbuf (double, int, int*, int*, char *);
+char *	fcvtbuf (double, int, int*, int*, char *);
+char *	ecvtf (float,int,int *,int *);
+#endif
+char *	__itoa (int, char *, int);
+char *	__utoa (unsigned, char *, int);
+#if __MISC_VISIBLE
+char *	itoa (int, char *, int);
+char *	utoa (unsigned, char *, int);
+#endif
+#if __POSIX_VISIBLE
+int	rand_r (unsigned *__seed);
+#endif
+
+#if __SVID_VISIBLE || __XSI_VISIBLE
+double drand48 (void);
+double _drand48_r (struct _reent *);
+double erand48 (unsigned short [3]);
+double _erand48_r (struct _reent *, unsigned short [3]);
+long   jrand48 (unsigned short [3]);
+long   _jrand48_r (struct _reent *, unsigned short [3]);
+void  lcong48 (unsigned short [7]);
+void  _lcong48_r (struct _reent *, unsigned short [7]);
+long   lrand48 (void);
+long   _lrand48_r (struct _reent *);
+long   mrand48 (void);
+long   _mrand48_r (struct _reent *);
+long   nrand48 (unsigned short [3]);
+long   _nrand48_r (struct _reent *, unsigned short [3]);
+unsigned short *
+       seed48 (unsigned short [3]);
+unsigned short *
+       _seed48_r (struct _reent *, unsigned short [3]);
+void  srand48 (long);
+void  _srand48_r (struct _reent *, long);
+#endif /* __SVID_VISIBLE || __XSI_VISIBLE */
+#if __SVID_VISIBLE || __XSI_VISIBLE >= 4 || __BSD_VISIBLE
+char *	initstate (unsigned, char *, size_t);
+long	random (void);
+char *	setstate (char *);
+void	srandom (unsigned);
+#endif
+#if __ISO_C_VISIBLE >= 1999
+long long atoll (const char *__nptr);
+#endif
+long long _atoll_r (struct _reent *, const char *__nptr);
+#if __ISO_C_VISIBLE >= 1999
+long long llabs (long long);
+lldiv_t	lldiv (long long __numer, long long __denom);
+long long strtoll (const char *__restrict __n, char **__restrict __end_PTR, int __base);
+#endif
+long long _strtoll_r (struct _reent *, const char *__restrict __n, char **__restrict __end_PTR, int __base);
+#if __ISO_C_VISIBLE >= 1999
+unsigned long long strtoull (const char *__restrict __n, char **__restrict __end_PTR, int __base);
+#endif
+unsigned long long _strtoull_r (struct _reent *, const char *__restrict __n, char **__restrict __end_PTR, int __base);
+
+#ifndef __CYGWIN__
+#if __MISC_VISIBLE
+void	cfree (void *);
+#endif
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
+int	unsetenv (const char *__string);
+#endif
+int	_unsetenv_r (struct _reent *, const char *__string);
+#endif /* !__CYGWIN__ */
+
+#if __POSIX_VISIBLE >= 200112
+int	posix_memalign (void **, size_t, size_t) __nonnull((1))
+	    __result_use_check;
+#endif
+
+char *	_dtoa_r (struct _reent *, double, int, int, int *, int*, char**);
+#ifndef __CYGWIN__
+void *	_malloc_r (struct _reent *, size_t) _NOTHROW;
+void *	_calloc_r (struct _reent *, size_t, size_t) _NOTHROW;
+void	_free_r (struct _reent *, void *) _NOTHROW;
+void *	_realloc_r (struct _reent *, void *, size_t) _NOTHROW;
+void	_mstats_r (struct _reent *, char *);
+#endif
+int	_system_r (struct _reent *, const char *);
+
+void	__eprintf (const char *, const char *, unsigned int, const char *);
+
+/* There are two common qsort_r variants.  If you request
+   _BSD_SOURCE, you get the BSD version; otherwise you get the GNU
+   version.  We want that #undef qsort_r will still let you
+   invoke the underlying function, but that requires gcc support. */
+#if __GNU_VISIBLE
+void	qsort_r (void *__base, size_t __nmemb, size_t __size, int (*_compar)(const void *, const void *, void *), void *__thunk);
+#elif __BSD_VISIBLE
+# ifdef __GNUC__
+void	qsort_r (void *__base, size_t __nmemb, size_t __size, void *__thunk, int (*_compar)(void *, const void *, const void *))
+             __asm__ (__ASMNAME ("__bsd_qsort_r"));
+# else
+void	__bsd_qsort_r (void *__base, size_t __nmemb, size_t __size, void *__thunk, int (*_compar)(void *, const void *, const void *));
+#  define qsort_r __bsd_qsort_r
+# endif
+#endif
+
+/* On platforms where long double equals double.  */
+#ifdef _HAVE_LONG_DOUBLE
+extern long double _strtold_r (struct _reent *, const char *__restrict, char **__restrict);
+#if __ISO_C_VISIBLE >= 1999
+extern long double strtold (const char *__restrict, char **__restrict);
+#endif
+#endif /* _HAVE_LONG_DOUBLE */
+
+/*
+ * If we're in a mode greater than C99, expose C11 functions.
+ */
+#if __ISO_C_VISIBLE >= 2011
+void *	aligned_alloc(size_t, size_t) __malloc_like __alloc_align(1)
+	    __alloc_size(2) __result_use_check;
+int	at_quick_exit(void (*)(void));
+_Noreturn void
+	quick_exit(int);
+#endif /* __ISO_C_VISIBLE >= 2011 */
+
+_END_STD_C
+
+#if __SSP_FORTIFY_LEVEL > 0
+#include <ssp/stdlib.h>
+#endif
+
+#endif /* _STDLIB_H_ */

package/src/platforms/gba/lib/libgba/sysinclude/string.h

@@ -0,0 +1,183 @@
+/*
+ * string.h
+ *
+ * Definitions for memory and string functions.
+ */
+
+#ifndef _STRING_H_
+#define	_STRING_H_
+
+#include "_ansi.h"
+#include <sys/reent.h>
+#include <sys/cdefs.h>
+#include <sys/features.h>
+
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+
+#if __POSIX_VISIBLE >= 200809
+#include <sys/_locale.h>
+#endif
+
+#if __BSD_VISIBLE
+#include <strings.h>
+#endif
+
+_BEGIN_STD_C
+
+void *	 memchr (const void *, int, size_t);
+int 	 memcmp (const void *, const void *, size_t);
+void *	 memcpy (void *__restrict, const void *__restrict, size_t);
+void *	 memmove (void *, const void *, size_t);
+void *	 memset (void *, int, size_t);
+char 	*strcat (char *__restrict, const char *__restrict);
+char 	*strchr (const char *, int);
+int	 strcmp (const char *, const char *);
+int	 strcoll (const char *, const char *);
+char 	*strcpy (char *__restrict, const char *__restrict);
+size_t	 strcspn (const char *, const char *);
+char 	*strerror (int);
+size_t	 strlen (const char *);
+char 	*strncat (char *__restrict, const char *__restrict, size_t);
+int	 strncmp (const char *, const char *, size_t);
+char 	*strncpy (char *__restrict, const char *__restrict, size_t);
+char 	*strpbrk (const char *, const char *);
+char 	*strrchr (const char *, int);
+size_t	 strspn (const char *, const char *);
+char 	*strstr (const char *, const char *);
+#ifndef _REENT_ONLY
+char 	*strtok (char *__restrict, const char *__restrict);
+#endif
+size_t	 strxfrm (char *__restrict, const char *__restrict, size_t);
+
+#if __POSIX_VISIBLE >= 200809
+int	 strcoll_l (const char *, const char *, locale_t);
+char	*strerror_l (int, locale_t);
+size_t	 strxfrm_l (char *__restrict, const char *__restrict, size_t, locale_t);
+#endif
+#if __MISC_VISIBLE || __POSIX_VISIBLE
+char 	*strtok_r (char *__restrict, const char *__restrict, char **__restrict);
+#endif
+#if __BSD_VISIBLE
+int	 timingsafe_bcmp (const void *, const void *, size_t);
+int	 timingsafe_memcmp (const void *, const void *, size_t);
+#endif
+#if __MISC_VISIBLE || __POSIX_VISIBLE
+void *	 memccpy (void *__restrict, const void *__restrict, int, size_t);
+#endif
+#if __GNU_VISIBLE
+void *	 mempcpy (void *, const void *, size_t);
+void *	 memmem (const void *, size_t, const void *, size_t);
+void *	 memrchr (const void *, int, size_t);
+void *	 rawmemchr (const void *, int);
+#endif
+#if __POSIX_VISIBLE >= 200809
+char 	*stpcpy (char *__restrict, const char *__restrict);
+char 	*stpncpy (char *__restrict, const char *__restrict, size_t);
+#endif
+#if __GNU_VISIBLE
+char	*strcasestr (const char *, const char *);
+char 	*strchrnul (const char *, int);
+#endif
+#if __MISC_VISIBLE || __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 4
+char 	*strdup (const char *) __malloc_like __result_use_check;
+#endif
+char 	*_strdup_r (struct _reent *, const char *);
+#if __POSIX_VISIBLE >= 200809
+char 	*strndup (const char *, size_t) __malloc_like __result_use_check;
+#endif
+char 	*_strndup_r (struct _reent *, const char *, size_t);
+
+/* There are two common strerror_r variants.  If you request
+   _GNU_SOURCE, you get the GNU version; otherwise you get the POSIX
+   version.  POSIX requires that #undef strerror_r will still let you
+   invoke the underlying function, but that requires gcc support.  */
+#if __GNU_VISIBLE
+char	*strerror_r (int, char *, size_t);
+#elif __POSIX_VISIBLE >= 200112
+# ifdef __GNUC__
+int	strerror_r (int, char *, size_t)
+#ifdef __ASMNAME
+             __asm__ (__ASMNAME ("__xpg_strerror_r"))
+#endif
+  ;
+# else
+int	__xpg_strerror_r (int, char *, size_t);
+#  define strerror_r __xpg_strerror_r
+# endif
+#endif
+
+/* Reentrant version of strerror.  */
+char *	_strerror_r (struct _reent *, int, int, int *);
+
+#if __BSD_VISIBLE
+size_t	strlcat (char *, const char *, size_t);
+size_t	strlcpy (char *, const char *, size_t);
+#endif
+#if __POSIX_VISIBLE >= 200809
+size_t	 strnlen (const char *, size_t);
+#endif
+#if __BSD_VISIBLE
+char 	*strsep (char **, const char *);
+#endif
+#if __BSD_VISIBLE
+char    *strnstr(const char *, const char *, size_t) __pure;
+#endif
+
+#if __MISC_VISIBLE
+char	*strlwr (char *);
+char	*strupr (char *);
+#endif
+
+#if __POSIX_VISIBLE >= 200809
+char	*strsignal (int __signo);
+#endif
+
+#ifdef __CYGWIN__
+int	strtosigno (const char *__name);
+#endif
+
+#if __GNU_VISIBLE
+int	 strverscmp (const char *, const char *);
+#endif
+
+#if __GNU_VISIBLE && defined(__GNUC__)
+#define strdupa(__s) \
+	(__extension__ ({const char *__sin = (__s); \
+			 size_t __len = strlen (__sin) + 1; \
+			 char * __sout = (char *) __builtin_alloca (__len); \
+			 (char *) memcpy (__sout, __sin, __len);}))
+#define strndupa(__s, __n) \
+	(__extension__ ({const char *__sin = (__s); \
+			 size_t __len = strnlen (__sin, (__n)) + 1; \
+			 char *__sout = (char *) __builtin_alloca (__len); \
+			 __sout[__len-1] = '\0'; \
+			 (char *) memcpy (__sout, __sin, __len-1);}))
+#endif /* __GNU_VISIBLE && __GNUC__ */
+
+/* There are two common basename variants.  If you do NOT #include <libgen.h>
+   and you do
+
+     #define _GNU_SOURCE
+     #include <string.h>
+
+   you get the GNU version.  Otherwise you get the POSIX versionfor which you
+   should #include <libgen.h>i for the function prototype.  POSIX requires that
+   #undef basename will still let you invoke the underlying function.  However,
+   this also implies that the POSIX version is used in this case.  That's made
+   sure here. */
+#if __GNU_VISIBLE && !defined(basename)
+# define basename basename
+char	*__nonnull ((1)) basename (const char *) __asm__(__ASMNAME("__gnu_basename"));
+#endif
+
+#include <sys/string.h>
+
+_END_STD_C
+
+#if __SSP_FORTIFY_LEVEL > 0
+#include <ssp/string.h>
+#endif
+
+#endif /* _STRING_H_ */

package/src/platforms/gba/lib/libgba/sysinclude/strings.h

@@ -0,0 +1,80 @@
+/*-
+ * Copyright (c) 2002 Mike Barcroft <mike@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: head/include/strings.h 272673 2014-10-07 04:54:11Z delphij $
+ */
+
+#ifndef _STRINGS_H_
+#define	_STRINGS_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#if __POSIX_VISIBLE >= 200809
+#include <sys/_locale.h>
+#endif
+
+#ifndef _SIZE_T_DECLARED
+typedef	__size_t	size_t;
+#define	_SIZE_T_DECLARED
+#endif
+
+__BEGIN_DECLS
+#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
+int	 bcmp(const void *, const void *, size_t) __pure;	/* LEGACY */
+void	 bcopy(const void *, void *, size_t);			/* LEGACY */
+void	 bzero(void *, size_t);					/* LEGACY */
+#endif
+#if __BSD_VISIBLE
+void	 explicit_bzero(void *, size_t);
+#endif
+#if __MISC_VISIBLE || __POSIX_VISIBLE < 200809 || __XSI_VISIBLE >= 700
+int	 ffs(int) __pure2;
+#endif
+#if __BSD_VISIBLE
+int	 ffsl(long) __pure2;
+int	 ffsll(long long) __pure2;
+int	 fls(int) __pure2;
+int	 flsl(long) __pure2;
+int	 flsll(long long) __pure2;
+#endif
+#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
+char	*index(const char *, int) __pure;			/* LEGACY */
+char	*rindex(const char *, int) __pure;			/* LEGACY */
+#endif
+int	 strcasecmp(const char *, const char *) __pure;
+int	 strncasecmp(const char *, const char *, size_t) __pure;
+
+#if __POSIX_VISIBLE >= 200809
+int	 strcasecmp_l (const char *, const char *, locale_t);
+int	 strncasecmp_l (const char *, const char *, size_t, locale_t);
+#endif
+__END_DECLS
+
+#if __SSP_FORTIFY_LEVEL > 0
+#include <ssp/strings.h>
+#endif
+
+#endif /* _STRINGS_H_ */