arnavbhatt288/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

Newlib source code

Browse Source 
git-svn-id: svn://kolibrios.org@1693 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge) 2010-11-07 13:42:29 +00:00
parent f189914288
commit 0a3f4b2193
254 changed files with 53522 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
programs/develop/libraries/newlib/crt/chkstk.S Normal file
View File

@ -0,0 +1,29 @@
.global ___chkstk
.global __alloca
.section .text
.align 4
___chkstk:
__alloca:
pushl %ecx /* save temp */
leal 8(%esp), %ecx /* point past return addr */
subl %eax, %ecx
cmpl %fs:4, %ecx # check low stack limit
jb 1f
movl %esp, %eax /* save old stack pointer */
movl %ecx, %esp /* decrement stack */
movl (%eax), %ecx /* recover saved temp */
movl 4(%eax), %eax /* recover return address */
/* Push the return value back. Doing this instead of just
jumping to %eax preserves the cached call-return stack
used by most modern processors. */
pushl %eax
ret
1:
int3 #trap to debugger
.ascii "Stack overflow"

72
programs/develop/libraries/newlib/crt/cpu_features.c Normal file
View File

@ -0,0 +1,72 @@
#include "cpu_features.h"
/* level 1 edx bits */
#define EDX_CX8 (1 << 8) /* CMPXCHG8B */
#define EDX_CMOV (1 << 15)
#define EDX_MMX (1 << 23)
#define EDX_FXSR (1 << 24) /* FXSAVE and FXRSTOR */
#define EDX_SSE (1 << 25)
#define EDX_SSE2 (1 << 26)
/* level 1 ecx bits */
#define ECX_SSE3 (1 << 0)
#define ECX_CX16 (1 << 13) /* CMPXCHG16B */
/* extended level 0x80000001 edx bits */
#define EDX_3DNOW (1 << 31)
#define EDX_3DNOWP (1 << 30)
#define EDX_LM (1 << 29) /*LONG MODE */
#define __cpuid(level,a,b,c,d) \
__asm__ __volatile__ ("cpuid;" \
: "=a" (a), "=b" (b), "=c" (c), "=d" (d)\
: "0" (level))
/* Combine the different cpuid flags into a single bitmap. */
unsigned int __cpu_features = 0;
void __cpu_features_init (void)
{
unsigned int eax, ebx, ecx, edx;
__cpuid (0, eax, ebx, ecx, edx);
if (eax == 0)
return;
__cpuid (1, eax, ebx, ecx, edx);
if (edx & EDX_CX8)
__cpu_features |= _CRT_CMPXCHG8B;
if (edx & EDX_CMOV)
__cpu_features |= _CRT_CMOV;
if (edx & EDX_MMX)
__cpu_features |= _CRT_MMX;
if (edx & EDX_FXSR)
__cpu_features |= _CRT_FXSR;
if (edx & EDX_SSE)
__cpu_features |= _CRT_SSE;
if (edx & EDX_SSE2)
__cpu_features |= _CRT_SSE2;
if (ecx & ECX_SSE3)
__cpu_features |= _CRT_SSE3;
if (ecx & ECX_CX16)
__cpu_features |= _CRT_CMPXCHG16B;
__cpuid (0x80000000, eax, ebx, ecx, edx);
if (eax < 0x80000001)
return;
__cpuid (0x80000001, eax, ebx, ecx, edx);
if (edx & EDX_3DNOW)
__cpu_features |= _CRT_3DNOW;
if (edx & EDX_3DNOWP)
__cpu_features |= _CRT_3DNOWP;
return;
}

21
programs/develop/libraries/newlib/crt/cpu_features.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef _CPU_FEATURES_H
#define _CPU_FEATURES_H
#define _CRT_CMPXCHG8B 0x0001
#define _CRT_CMOV 0x0002
#define _CRT_MMX 0x0004
#define _CRT_FXSR 0x0008
#define _CRT_SSE 0x0010
#define _CRT_SSE2 0x0020
#define _CRT_SSE3 0x0040
#define _CRT_CMPXCHG16B 0x0080
#define _CRT_3DNOW 0x0100
#define _CRT_3DNOWP 0x0200
extern unsigned int __cpu_features;
/* Currently we use this in fpenv functions */
#define __HAS_SSE __cpu_features & _CRT_SSE
#endif

126
programs/develop/libraries/newlib/crt/crt1.c Normal file
View File

@ -0,0 +1,126 @@
/*
* crt1.c
* This file has no copyright assigned and is placed in the Public Domain.
* This file is a part of the mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER within the package.
*
* Source code for the startup proceedures used by all programs. This code
* is compiled to make crt1.o, which should be located in the library path.
*
*/
/* Hide the declaration of _fmode with dllimport attribute in stdlib.h to
avoid problems with older GCC. */
#include <newlib.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "cpu_features.h"
/* NOTE: The code for initializing the _argv, _argc, and environ variables
* has been moved to a separate .c file which is included in both
* crt1.c and dllcrt1.c. This means changes in the code don't have to
* be manually synchronized, but it does lead to this not-generally-
* a-good-idea use of include. */
extern char __cmdline;
extern char __pgmname;
extern int main (int, char **, char **);
int _errno;
int _fmode;
char __appcwd[1024];
int __appcwdlen;
int _argc;
char **_argv;
static char *arg[2];
void _exit(int __status) __attribute__((noreturn));
char * __libc_getenv(const char *name)
{
return NULL;
}
void __main (){};
void init_reent();
void __attribute__((noreturn))
__thread_startup (int (*entry)(void*), void *param,
void *stacklow, void *stackhigh)
{
int retval;
__asm__ __volatile__( // save stack limits
"movl %0, %%fs:4 \n\t" // use TLS
"movl %1, %%fs:8 \n\t"
::"r"(stacklow), "r"(stackhigh));
init_reent(); // initialize thread reentry structure
retval = entry(param); // call user thread function
_exit(retval);
};
void __attribute__((noreturn))
__crt_startup (void)
{
int nRet;
init_reent();
/*
* Initialize floating point unit.
*/
__cpu_features_init (); /* Do we have SSE, etc.*/
// _fpreset (); /* Supplied by the runtime library. */
__initPOSIXHandles();
__appcwdlen = strrchr(&__pgmname, '/') - &__pgmname + 1;
__appcwdlen = __appcwdlen > 1023 ? 1023 : __appcwdlen;
strncpy(__appcwd, &__pgmname, __appcwdlen);
__appcwd[__appcwdlen] = 0;
arg[0] = &__pgmname;
if( __cmdline != 0)
{
_argc = 2;
arg[1] = &__cmdline;
} else _argc = 1;
_argv = arg;
/*
* Sets the default file mode.
* If _CRT_fmode is set, also set mode for stdin, stdout
* and stderr, as well
* NOTE: DLLs don't do this because that would be rude!
*/
// _mingw32_init_fmode ();
nRet = main (_argc, _argv, NULL);
/*
* Perform exit processing for the C library. This means
* flushing output and calling 'atexit' registered functions.
*/
_exit (nRet);
}

40
programs/develop/libraries/newlib/crt/start.S Normal file
View File

@ -0,0 +1,40 @@
.section .init
.global __start
.global __exit
.global __Exit
.align 4
__start:
movl $68, %eax
movl $12, %ebx
lea __size_of_stack_reserve__, %ecx
addl $4095, %ecx #load stack size
andl $-4096, %ecx #align to page granularity
int $0x40 #and allocate
testl %eax, %eax
jz 1f
addl %eax, %ecx
movl %eax, %fs:4
movl %ecx, %fs:8 #save stack base - low limit
#save stack top - high limit
movl %ecx, %esp
jmp ___crt_startup #reload stack
1:
int3 #trap to debugger
.ascii "No enough memory for stack allocation"
.align 4
__exit:
__Exit:
movl 4(%esp), %edx #store exit code
movl $68, %eax
movl $13, %ebx
movl %fs:4, %ecx
int $0x40 #destroy stack
movl $-1, %eax
int $0x40 #terminate thread

46
programs/develop/libraries/newlib/crt/thread.S Normal file
View File

@ -0,0 +1,46 @@
.global _create_thread
.global ___thread_startup
.section .text
.align 4
_create_thread:
#.thr_proc equ esp+8
#.param equ esp+12
#.stack_size equ esp+16
pushl %ebx
movl $68, %eax
movl $12, %ebx
movl 16(%esp), %ecx #[.stack_size]
addl $4095, %ecx
andl $-4096, %ecx
movl %ecx, 16(%esp) #save stack size
int $0x40
testl %eax, %eax
jz 1f
leal -20(%eax,%ecx), %edx
movl 8(%esp), %ebx #[.thr_proc]
mov %ebx, 4(%edx)
movl 12(%esp), %ebx #[.param]
movl %ebx, 8(%edx)
addl %eax, %ecx
movl %eax, 12(%edx) #stack low limit
movl %ecx, 16(%edx) #stack high limit
movl $51, %eax
movl $1, %ebx
lea ___thread_startup , %ecx
int $0x40
popl %ebx
ret
1:
notl %eax
popl %ebx
ret

223
programs/develop/libraries/newlib/ctype/ctype_.c Normal file
View File

@ -0,0 +1,223 @@
/*
* Copyright (c) 1989 The Regents of the University of California.
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*/
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)ctype_.c 5.6 (Berkeley) 6/1/90";
#endif /* LIBC_SCCS and not lint */
#include <ctype.h>
#define _CTYPE_DATA_0_127 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C|_S, _C|_S, _C|_S, _C|_S, _C|_S, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_N, _N, _N, _N, _N, _N, _N, _N, \
_N, _N, _P, _P, _P, _P, _P, _P, \
_P, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _P, _P, _P, _P, _P, \
_P, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _P, _P, _P, _P, _C
#define _CTYPE_DATA_128_255 \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0
#if (defined(__GNUC__) && !defined(__CHAR_UNSIGNED__) && !defined(COMPACT_CTYPE)) || defined (__CYGWIN__)
#define ALLOW_NEGATIVE_CTYPE_INDEX
#endif
#if defined(_MB_CAPABLE)
#if defined(_MB_EXTENDED_CHARSETS_ISO)
#include "ctype_iso.h"
#endif
#if defined(_MB_EXTENDED_CHARSETS_WINDOWS)
#include "ctype_cp.h"
#endif
#endif
#if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
/* No static const on Cygwin since it's referenced and potentially overwritten
for compatibility with older applications. */
#ifndef __CYGWIN__
static _CONST
#endif
char _ctype_b[128 + 256] = {
_CTYPE_DATA_128_255,
_CTYPE_DATA_0_127,
_CTYPE_DATA_128_255
};
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
#ifndef _MB_CAPABLE
_CONST
#endif
char __EXPORT *__ctype_ptr = (char *) _ctype_b + 128;
#endif
#ifndef _MB_CAPABLE
_CONST
#endif
char __EXPORT *__ctype_ptr__ = (char *) _ctype_b + 127;
# ifdef __CYGWIN__
__asm__ (" \n\
.data \n\
.globl __ctype_ \n\
.set __ctype_,__ctype_b+127 \n\
.text \n\
");
# else /* !__CYGWIN__ */
_CONST char _ctype_[1 + 256] = {
0,
_CTYPE_DATA_0_127,
_CTYPE_DATA_128_255
};
# endif /* !__CYGWIN__ */
#else /* !defined(ALLOW_NEGATIVE_CTYPE_INDEX) */
_CONST char _ctype_[1 + 256] = {
0,
_CTYPE_DATA_0_127,
_CTYPE_DATA_128_255
};
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
#ifndef _MB_CAPABLE
_CONST
#endif
char *__ctype_ptr = (char *) _ctype_ + 1;
#endif
#ifndef _MB_CAPABLE
_CONST
#endif
char *__ctype_ptr__ = (char *) _ctype_;
#endif
#if defined(_MB_CAPABLE)
/* Cygwin has its own implementation which additionally maintains backward
compatibility with applications built under older Cygwin releases. */
#ifndef __CYGWIN__
void
__set_ctype (const char *charset)
{
#if defined(_MB_EXTENDED_CHARSETS_ISO) || defined(_MB_EXTENDED_CHARSETS_WINDOWS)
int idx;
#endif
switch (*charset)
{
#if defined(_MB_EXTENDED_CHARSETS_ISO)
case 'I':
idx = __iso_8859_index (charset + 9);
/* The ctype table has a leading ISO-8859-1 element so we have to add
1 to the index returned by __iso_8859_index. If __iso_8859_index
returns < 0, it's ISO-8859-1. */
if (idx < 0)
idx = 0;
else
++idx;
# if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) (__ctype_iso[idx] + 128);
#endif
__ctype_ptr__ = (char *) (__ctype_iso[idx] + 127);
# else
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) __ctype_iso[idx] + 1;
#endif
__ctype_ptr__ = (char *) __ctype_iso[idx];
# endif
return;
#endif
#if defined(_MB_EXTENDED_CHARSETS_WINDOWS)
case 'C':
idx = __cp_index (charset + 2);
if (idx < 0)
break;
# if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) (__ctype_cp[idx] + 128);
#endif
__ctype_ptr__ = (char *) (__ctype_cp[idx] + 127);
# else
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) __ctype_cp[idx] + 1;
#endif
__ctype_ptr__ = (char *) __ctype_cp[idx];
# endif
return;
#endif
default:
break;
}
# if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) _ctype_b + 128;
#endif
__ctype_ptr__ = (char *) _ctype_b + 127;
# else
#ifdef _NEED_OLD_CTYPE_PTR_DEFINITION
__ctype_ptr = (char *) _ctype_ + 1;
#endif
__ctype_ptr__ = (char *) _ctype_;
# endif
}
#endif /* !__CYGWIN__ */
#endif /* _MB_CAPABLE */

775
programs/develop/libraries/newlib/ctype/ctype_cp.h Normal file
View File

@ -0,0 +1,775 @@
/* ctype table definitions for Windows codepage charsets.
Included by ctype_.c. */
#define _CTYPE_CP437_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _U, _U, \
_U, _L, _U, _L, _L, _L, _L, _L, \
_L, _U, _U, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _U, _L, _U, _L, _P, _L, \
_U, _U, _U, _L, _P, _L, _L, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP437_255 _S|_B
#define _CTYPE_CP720_128_254 \
0, 0, _L, _L, 0, _L, 0, _L, \
_L, _L, _L, _L, _L, 0, 0, 0, \
0, _P, _P, _L, _P, _P, _L, _L, \
_U|_L, _U|_L, _U|_L, _U|_L, _P, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _P, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP720_255 _S|_B
#define _CTYPE_CP737_128_254 \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _U, _U, _U, _U, _U, _U, \
_U, _P, _P, _P, _U, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP737_255 _S|_B
#define _CTYPE_CP775_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _U, _L, _L, _U, _U, _U, \
_U, _L, _U, _L, _L, _U, _P, _U, \
_L, _U, _U, _L, _P, _U, _P, _P, \
_U, _U, _L, _U, _L, _L, _P, _P, \
_P, _P, _P, _P, _P, _U, _P, _P, \
_P, _P, _P, _P, _P, _U, _U, _U, \
_U, _P, _P, _P, _P, _U, _U, _P, \
_P, _P, _P, _P, _P, _P, _U, _U, \
_P, _P, _P, _P, _P, _P, _P, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _P, _P, _P, _P, _P, _P, _P, \
_U, _L, _U, _U, _L, _U, _P, _L, \
_U, _L, _U, _L, _L, _U, _U, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP775_255 _S|_B
#define _CTYPE_CP850_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _U, _U, \
_U, _L, _U, _L, _L, _L, _L, _L, \
_L, _U, _U, _L, _P, _U, _P, _L, \
_L, _L, _L, _L, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _U, _U, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _L, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _U, _U, _U, _U, _L, _U, _U, \
_U, _P, _P, _P, _P, _P, _U, _P, \
_U, _L, _U, _U, _L, _U, _P, _L, \
_U, _U, _U, _U, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP850_255 _S|_B
#define _CTYPE_CP852_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _U, _L, _L, _U, _U, _U, \
_U, _U, _L, _L, _L, _U, _L, _U, \
_L, _U, _U, _U, _L, _U, _P, _L, \
_L, _L, _L, _L, _U, _L, _U, _L, \
_U, _L, _P, _L, _U, _L, _P, _P, \
_P, _P, _P, _P, _P, _U, _U, _U, \
_U, _P, _P, _P, _P, _U, _L, _P, \
_P, _P, _P, _P, _P, _P, _U, _L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _U, _U, _U, _L, _U, _U, _U, \
_L, _P, _P, _P, _P, _U, _U, _P, \
_U, _L, _U, _U, _L, _L, _U, _L, \
_U, _U, _L, _U, _L, _U, _L, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _L, _U, _L, _P
#define _CTYPE_CP852_255 _S|_B
#define _CTYPE_CP855_128_254 \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _U, _L, _U, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _L, _U, _L, \
_U, _P, _P, _P, _P, _L, _U, _P, \
_P, _P, _P, _P, _P, _P, _L, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _U, _L, _U, _L, _U, _L, _U, \
_L, _P, _P, _P, _P, _U, _L, _P, \
_U, _L, _U, _L, _U, _L, _U, _L, \
_U, _L, _U, _L, _U, _L, _U, _P, \
_P, _L, _U, _L, _U, _L, _U, _L, \
_U, _L, _U, _L, _U, _P, _P
#define _CTYPE_CP855_255 _S|_B
#define _CTYPE_CP857_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _U, _U, \
_U, _L, _U, _L, _L, _L, _L, _L, \
_U, _U, _U, _L, _P, _U, _U, _L, \
_L, _L, _L, _L, _L, _U, _U, _L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _U, _U, _U, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _L, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _U, _U, _U, 0, _U, _U, \
_U, _P, _P, _P, _P, _P, _U, _P, \
_U, _L, _U, _U, _L, _U, _P, 0, \
_P, _U, _U, _U, _L, _L, _P, _P, \
_P, _P, 0, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP857_255 _S|_B
#define _CTYPE_CP858_128_254 \
_U, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _U, _U, \
_U, _L, _U, _L, _L, _L, _L, _L, \
_L, _U, _U, _L, _P, _U, _P, _L, \
_L, _L, _L, _L, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _U, _U, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _L, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _U, _U, _U, _U, _P, _U, _U, \
_U, _P, _P, _P, _P, _P, _U, _P, \
_U, _L, _U, _U, _L, _U, _P, _L, \
_U, _U, _U, _U, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP858_255 _S|_B
#define _CTYPE_CP862_128_254 \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _P, _P, _P, _P, _L, \
_L, _L, _L, _L, _L, _U, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _U, _L, _U, _L, _P, _L, \
_U, _U, _U, _L, _P, _L, _L, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP862_255 _S|_B
#define _CTYPE_CP866_128_254 \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_U, _L, _U, _L, _U, _L, _U, _L, \
_P, _P, _P, _P, _P, _P, _P
#define _CTYPE_CP866_255 _S|_B
#define _CTYPE_CP874_128_254 \
_P, 0, 0, 0, 0, _P, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
0, 0, 0, 0, 0, 0, 0, 0, \
_S|_B, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, 0, 0, 0, 0, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _U|_L, _U|_L, 0, 0, 0
#define _CTYPE_CP874_255 0
#define _CTYPE_CP1125_128_254 \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_U, _L, _U, _L, _U, _L, _U, _L, \
_U, _L, _P, _P, _P, _P, _P
#define _CTYPE_CP1125_255 _S|_B
#define _CTYPE_CP1250_128_254 \
_P, 0, _P, 0, _P, _P, _P, _P, \
0, _P, _U, _P, _U, _U, _U, _U, \
0, _P, _P, _P, _P, _P, _P, _P, \
0, _P, _L, _P, _L, _L, _L, _L, \
_S|_B, _P, _P, _U, _P, _U, _P, _P, \
_P, _P, _U, _P, _P, _P, _P, _U, \
_P, _P, _P, _L, _P, _P, _P, _P, \
_P, _L, _L, _P, _U, _P, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1250_255 _P
#define _CTYPE_CP1251_128_254 \
_U, _U, _P, _L, _P, _P, _P, _P, \
_P, _P, _U, _P, _U, _U, _U, _U, \
_L, _P, _P, _P, _P, _P, _P, _P, \
0, _P, _L, _P, _L, _L, _L, _L, \
_S|_B, _U, _L, _U, _P, _U, _P, _P, \
_U, _P, _U, _P, _P, _P, _P, _U, \
_P, _P, _U, _L, _L, _P, _P, _P, \
_L, _P, _L, _P, _L, _U, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1251_255 _L
#define _CTYPE_CP1252_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
_P, _P, _U, _P, _U, _U, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _L, _P, _L, 0, _L, _U, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1252_255 _L
#define _CTYPE_CP1253_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
0, _P, 0, _P, 0, 0, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
0, _P, 0, _P, 0, 0, 0, 0, \
_S|_B, _P, _U, _P, _P, _P, _P, _P, \
_P, _P, 0, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _P, _U, _P, _U, _U, \
_L, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1253_255 _L
#define _CTYPE_CP1254_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
_P, _P, _U, _P, _U, 0, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _L, _P, _L, 0, 0, _U, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1254_255 _L
#define _CTYPE_CP1255_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
_P, _P, 0, _P, 0, 0, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, 0, _P, 0, 0, 0, 0, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _U|_L, _U|_L, _U|_L, _P, \
_P, 0, 0, 0, 0, 0, 0, 0, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, 0, 0, _P, _P
#define _CTYPE_CP1255_255 0
#define _CTYPE_CP1256_128_254 \
_P, _U|_L, _P, _L, _P, _P, _P, _P, \
_P, _P, _U|_L, _P, _U, _U|_L, _U|_L, _U|_L, \
_U|_L, _P, _P, _P, _P, _P, _P, _P, \
_U|_L, _P, _U|_L, _P, _L, _P, _P, _U|_L, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _U|_L, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _P, _U|_L, _U|_L, _U|_L, \
_L, _U|_L, _L, _U|_L, _U|_L, _U|_L, _U|_L, _L, \
_L, _L, _L, _L, _U|_L, _U|_L, _L, _L, \
_P, _P, _P, _P, _L, _P, _P, _P, \
_P, _L, _P, _L, _L, _P, _P
#define _CTYPE_CP1256_255 _U|_L
#define _CTYPE_CP1257_128_254 \
_P, 0, _P, 0, _P, _P, _P, _P, \
0, _P, 0, _P, 0, _P, _P, _P, \
0, _P, _P, _P, _P, _P, _P, _P, \
0, _P, 0, _P, 0, _P, _P, 0, \
_S|_B, 0, _P, _P, _P, 0, _P, _P, \
_U, _P, _U, _P, _P, _P, _P, _U, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _P, _L, _P, _P, _P, _P, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_CP1257_255 _P
#define _CTYPE_CP1258_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
_P, _P, 0, _P, _U, 0, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, 0, _P, _L, 0, 0, _U, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _P, _U, _U, _U, \
_U, _U, _P, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _P, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _P, _L, _L, _L, \
_L, _L, _P, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _P
#define _CTYPE_CP1258_255 _L
#define _CTYPE_CP20866_128_254 \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _S|_B, _P, _P, _P, _P, _P, \
_P, _P, _P, _L, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _U, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U
#define _CTYPE_CP20866_255 _U
#define _CTYPE_CP21866_128_254 \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _S|_B, _P, _P, _P, _P, _P, \
_P, _P, _P, _L, _L, _P, _L, _L, \
_P, _P, _P, _P, _P, _L, _P, _P, \
_P, _P, _P, _U, _U, _P, _U, _U, \
_P, _P, _P, _P, _P, _U, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U
#define _CTYPE_CP21866_255 _U
#define _CTYPE_GEORGIAN_PS_128_254 \
_P, 0, _P, _L, _P, _P, _P, _P, \
_P, _P, _U, _P, _U, _U, 0, 0, \
0, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _L, _P, _L, 0, _L, _U, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_GEORGIAN_PS_255 _L
#define _CTYPE_PT154_128_254 \
_U, _U, _U, _L, _P, _P, _U, _U, \
_U, _L, _U, _U, _U, _U, _U, _U, \
_L, _P, _P, _P, _P, _P, _P, _P, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_S|_B, _U, _L, _U, _U, _U, _U, _P, \
_U, _P, _U, _P, _P, _L, _P, _U, \
_P, _L, _U, _L, _L, _L, _P, _P, \
_L, _P, _L, _P, _L, _U, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_PT154_255 _L
extern int __cp_index (const char *charset_ext);
#if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
#ifndef __CYGWIN__
static _CONST
#endif
char __ctype_cp[26][128 + 256] = {
{ _CTYPE_CP437_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP437_128_254,
_CTYPE_CP437_255
},
{ _CTYPE_CP720_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP720_128_254,
_CTYPE_CP720_255
},
{ _CTYPE_CP737_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP737_128_254,
_CTYPE_CP737_255
},
{ _CTYPE_CP775_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP775_128_254,
_CTYPE_CP775_255
},
{ _CTYPE_CP850_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP850_128_254,
_CTYPE_CP850_255
},
{ _CTYPE_CP852_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP852_128_254,
_CTYPE_CP852_255
},
{ _CTYPE_CP855_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP855_128_254,
_CTYPE_CP855_255
},
{ _CTYPE_CP857_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP857_128_254,
_CTYPE_CP857_255
},
{ _CTYPE_CP858_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP858_128_254,
_CTYPE_CP858_255
},
{ _CTYPE_CP862_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP862_128_254,
_CTYPE_CP862_255
},
{ _CTYPE_CP866_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP866_128_254,
_CTYPE_CP866_255
},
{ _CTYPE_CP874_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP874_128_254,
_CTYPE_CP874_255
},
{ _CTYPE_CP1125_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1125_128_254,
_CTYPE_CP1125_255
},
{ _CTYPE_CP1250_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1250_128_254,
_CTYPE_CP1250_255
},
{ _CTYPE_CP1251_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1251_128_254,
_CTYPE_CP1251_255
},
{ _CTYPE_CP1252_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1252_128_254,
_CTYPE_CP1252_255
},
{ _CTYPE_CP1253_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1253_128_254,
_CTYPE_CP1253_255
},
{ _CTYPE_CP1254_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1254_128_254,
_CTYPE_CP1254_255
},
{ _CTYPE_CP1255_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1255_128_254,
_CTYPE_CP1255_255
},
{ _CTYPE_CP1256_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1256_128_254,
_CTYPE_CP1256_255
},
{ _CTYPE_CP1257_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1257_128_254,
_CTYPE_CP1257_255
},
{ _CTYPE_CP1258_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP1258_128_254,
_CTYPE_CP1258_255
},
{ _CTYPE_CP20866_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP20866_128_254,
_CTYPE_CP20866_255
},
{ _CTYPE_CP21866_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_CP21866_128_254,
_CTYPE_CP21866_255
},
{ _CTYPE_GEORGIAN_PS_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_GEORGIAN_PS_128_254,
_CTYPE_GEORGIAN_PS_255
},
{ _CTYPE_PT154_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_PT154_128_254,
_CTYPE_PT154_255
},
};
#else /* !defined(ALLOW_NEGATIVE_CTYPE_INDEX) */
static _CONST char __ctype_cp[26][1 + 256] = {
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP437_128_254,
_CTYPE_CP437_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP720_128_254,
_CTYPE_CP720_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP737_128_254,
_CTYPE_CP737_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP775_128_254,
_CTYPE_CP775_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP850_128_254,
_CTYPE_CP850_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP852_128_254,
_CTYPE_CP852_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP855_128_254,
_CTYPE_CP855_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP857_128_254,
_CTYPE_CP857_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP858_128_254,
_CTYPE_CP858_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP862_128_254,
_CTYPE_CP862_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP866_128_254,
_CTYPE_CP866_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP874_128_254,
_CTYPE_CP874_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1125_128_254,
_CTYPE_CP1125_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1250_128_254,
_CTYPE_CP1250_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1251_128_254,
_CTYPE_CP1251_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1252_128_254,
_CTYPE_CP1252_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1253_128_254,
_CTYPE_CP1253_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1254_128_254,
_CTYPE_CP1254_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1255_128_254,
_CTYPE_CP1255_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1256_128_254,
_CTYPE_CP1256_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1257_128_254,
_CTYPE_CP1257_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP1258_128_254,
_CTYPE_CP1258_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP20866_128_254,
_CTYPE_CP20866_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_CP21866_128_254,
_CTYPE_CP21866_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_GEORGIAN_PS_128_254,
_CTYPE_GEORGIAN_PS_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_PT154_128_254,
_CTYPE_PT154_255
},
};
#endif /* ALLOW_NEGATIVE_CTYPE_INDEX */

455
programs/develop/libraries/newlib/ctype/ctype_iso.h Normal file
View File

@ -0,0 +1,455 @@
/* ctype table definitions for ISO-8859-x charsets.
Included by ctype_.c. */
#define _CTYPE_ISO_8859_1_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_1_255 _L
#define _CTYPE_ISO_8859_2_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _P, _U, _P, _U, _U, _P, \
_P, _U, _U, _U, _U, _P, _U, _U, \
_P, _L, _P, _L, _P, _L, _L, _P, \
_P, _L, _L, _L, _L, _P, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_2_255 _P
#define _CTYPE_ISO_8859_3_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _P, _P, _P, 0, _U, _P, \
_P, _U, _U, _U, _U, _P, 0, _U, \
_P, _L, _P, _P, _P, _P, _L, _P, \
_P, _L, _L, _L, _L, _P, 0, _L, \
_U, _U, _U, 0, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
0, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, 0, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
0, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_3_255 _P
#define _CTYPE_ISO_8859_4_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _L, _U, _P, _U, _U, _P, \
_P, _U, _U, _U, _U, _P, _U, _P, \
_P, _L, _P, _L, _P, _L, _L, _P, \
_P, _L, _L, _L, _L, _P, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_4_255 _L
#define _CTYPE_ISO_8859_5_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _P, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_P, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _P, _L
#define _CTYPE_ISO_8859_5_255 _L
#define _CTYPE_ISO_8859_6_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, 0, 0, 0, _P, 0, 0, 0, \
0, 0, 0, 0, _P, _P, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, _P, 0, 0, 0, _P, \
0, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, 0, 0, 0, 0, 0, \
_P, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _P, _P, _P, _P, _P, \
_P, _P, _P, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0
#define _CTYPE_ISO_8859_6_255 0
#define _CTYPE_ISO_8859_7_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, 0, _P, \
_P, _P, _P, _P, _P, _P, _U, _P, \
_U, _U, _U, _P, _U, _P, _U, _U, \
_L, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_7_255 0
#define _CTYPE_ISO_8859_8_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, 0, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, 0, 0, _P, _P
#define _CTYPE_ISO_8859_8_255 0
#define _CTYPE_ISO_8859_9_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_9_255 _L
#define _CTYPE_ISO_8859_10_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _P, _U, _U, \
_P, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _P, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_10_255 _L
#define _CTYPE_ISO_8859_11_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _P, _U|_L, _U|_L, _P, _P, _P, _P, \
_P, _P, _P, 0, 0, 0, 0, _P, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _P, \
_P, _P, _P, _P, _P, _P, _P, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, _U|_L, \
_U|_L, _U|_L, _U|_L, _U|_L, 0, 0, 0
#define _CTYPE_ISO_8859_11_255 0
#define _CTYPE_ISO_8859_13_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _P, _P, \
_U, _P, _U, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _P, _P, _P, _P, \
_L, _P, _L, _P, _P, _P, _P, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_13_255 _P
#define _CTYPE_ISO_8859_14_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _L, _P, _U, _L, _U, _P, \
_U, _P, _U, _L, _U, _P, _P, _U, \
_U, _L, _U, _L, _U, _L, _P, _U, \
_L, _L, _L, _U, _L, _U, _L, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_14_255 _L
#define _CTYPE_ISO_8859_15_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _P, _P, _P, _P, _P, _U, _P, \
_L, _P, _P, _P, _P, _P, _P, _P, \
_P, _P, _P, _P, _U, _P, _P, _P, \
_L, _P, _P, _P, _U, _L, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _P, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _P, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_15_255 _L
#define _CTYPE_ISO_8859_16_128_254 \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_C, _C, _C, _C, _C, _C, _C, _C, \
_S|_B, _U, _L, _U, _P, _P, _U, _P, \
_L, _P, _U, _P, _U, _P, _L, _U, \
_P, _P, _U, _U, _U, _P, _P, _P, \
_L, _L, _L, _P, _U, _L, _U, _L, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _U, \
_U, _U, _U, _U, _U, _U, _U, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L, _L, \
_L, _L, _L, _L, _L, _L, _L
#define _CTYPE_ISO_8859_16_255 _L
extern int __iso_8859_index (const char *charset_ext);
#if defined(ALLOW_NEGATIVE_CTYPE_INDEX)
#ifndef __CYGWIN__
static _CONST
#endif
char __ctype_iso[15][128 + 256] = {
{ _CTYPE_ISO_8859_1_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_1_128_254,
_CTYPE_ISO_8859_1_255
},
{ _CTYPE_ISO_8859_2_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_2_128_254,
_CTYPE_ISO_8859_2_255
},
{ _CTYPE_ISO_8859_3_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_3_128_254,
_CTYPE_ISO_8859_3_255
},
{ _CTYPE_ISO_8859_4_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_4_128_254,
_CTYPE_ISO_8859_4_255
},
{ _CTYPE_ISO_8859_5_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_5_128_254,
_CTYPE_ISO_8859_5_255
},
{ _CTYPE_ISO_8859_6_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_6_128_254,
_CTYPE_ISO_8859_6_255
},
{ _CTYPE_ISO_8859_7_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_7_128_254,
_CTYPE_ISO_8859_7_255
},
{ _CTYPE_ISO_8859_8_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_8_128_254,
_CTYPE_ISO_8859_8_255
},
{ _CTYPE_ISO_8859_9_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_9_128_254,
_CTYPE_ISO_8859_9_255
},
{ _CTYPE_ISO_8859_10_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_10_128_254,
_CTYPE_ISO_8859_10_255
},
{ _CTYPE_ISO_8859_11_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_11_128_254,
_CTYPE_ISO_8859_11_255
},
{ _CTYPE_ISO_8859_13_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_13_128_254,
_CTYPE_ISO_8859_13_255
},
{ _CTYPE_ISO_8859_14_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_14_128_254,
_CTYPE_ISO_8859_14_255
},
{ _CTYPE_ISO_8859_15_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_15_128_254,
_CTYPE_ISO_8859_15_255
},
{ _CTYPE_ISO_8859_16_128_254,
0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_16_128_254,
_CTYPE_ISO_8859_16_255
},
};
#else /* !defined(ALLOW_NEGATIVE_CTYPE_INDEX) */
static _CONST char __ctype_iso[15][1 + 256] = {
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_1_128_254,
_CTYPE_ISO_8859_1_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_2_128_254,
_CTYPE_ISO_8859_2_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_3_128_254,
_CTYPE_ISO_8859_3_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_4_128_254,
_CTYPE_ISO_8859_4_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_5_128_254,
_CTYPE_ISO_8859_5_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_6_128_254,
_CTYPE_ISO_8859_6_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_7_128_254,
_CTYPE_ISO_8859_7_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_8_128_254,
_CTYPE_ISO_8859_8_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_9_128_254,
_CTYPE_ISO_8859_9_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_10_128_254,
_CTYPE_ISO_8859_10_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_11_128_254,
_CTYPE_ISO_8859_11_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_13_128_254,
_CTYPE_ISO_8859_13_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_14_128_254,
_CTYPE_ISO_8859_14_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_15_128_254,
_CTYPE_ISO_8859_15_255
},
{ 0,
_CTYPE_DATA_0_127,
_CTYPE_ISO_8859_16_128_254,
_CTYPE_ISO_8859_16_255
},
};
#endif /* ALLOW_NEGATIVE_CTYPE_INDEX */

46
programs/develop/libraries/newlib/ctype/isalnum.c Normal file
View File

@ -0,0 +1,46 @@
/*
FUNCTION
<<isalnum>>---alphanumeric character predicate
INDEX
isalnum
ANSI_SYNOPSIS
#include <ctype.h>
int isalnum(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isalnum(<[c]>);
DESCRIPTION
<<isalnum>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for alphabetic or
numeric ASCII characters, and <<0>> for other arguments. It is defined
for all integer values.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalnum>>'.
RETURNS
<<isalnum>> returns non-zero if <[c]> is a letter (<<a>>--<<z>> or
<<A>>--<<Z>>) or a digit (<<0>>--<<9>>).
PORTABILITY
<<isalnum>> is ANSI C.
No OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isalnum
int
_DEFUN(isalnum,(c),int c)
{
return(__ctype_ptr__[c+1] & (_U|_L|_N));
}

44
programs/develop/libraries/newlib/ctype/isalpha.c Normal file
View File

@ -0,0 +1,44 @@
/*
FUNCTION
<<isalpha>>---alphabetic character predicate
INDEX
isalpha
ANSI_SYNOPSIS
#include <ctype.h>
int isalpha(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isalpha(<[c]>);
DESCRIPTION
<<isalpha>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero when <[c]> represents an
alphabetic ASCII character, and 0 otherwise. It is defined only when
<<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isalpha>>'.
RETURNS
<<isalpha>> returns non-zero if <[c]> is a letter (<<A>>--<<Z>> or
<<a>>--<<z>>).
PORTABILITY
<<isalpha>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isalpha
int
_DEFUN(isalpha,(c),int c)
{
return(__ctype_ptr__[c+1] & (_U|_L));
}

48
programs/develop/libraries/newlib/ctype/iscntrl.c Normal file
View File

@ -0,0 +1,48 @@
/*
FUNCTION
<<iscntrl>>---control character predicate
INDEX
iscntrl
ANSI_SYNOPSIS
#include <ctype.h>
int iscntrl(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int iscntrl(<[c]>);
DESCRIPTION
<<iscntrl>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for control characters, and 0
for other characters. It is defined only when <<isascii>>(<[c]>) is
true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef iscntrl>>'.
RETURNS
<<iscntrl>> returns non-zero if <[c]> is a delete character or ordinary
control character (<<0x7F>> or <<0x00>>--<<0x1F>>).
PORTABILITY
<<iscntrl>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef iscntrl
int
_DEFUN(iscntrl,(c),int c)
{
return(__ctype_ptr__[c+1] & _C);
}

43
programs/develop/libraries/newlib/ctype/isdigit.c Normal file
View File

@ -0,0 +1,43 @@
/*
FUNCTION
<<isdigit>>---decimal digit predicate
INDEX
isdigit
ANSI_SYNOPSIS
#include <ctype.h>
int isdigit(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isdigit(<[c]>);
DESCRIPTION
<<isdigit>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for decimal digits, and 0 for
other characters. It is defined only when <<isascii>>(<[c]>) is true
or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isdigit>>'.
RETURNS
<<isdigit>> returns non-zero if <[c]> is a decimal digit (<<0>>--<<9>>).
PORTABILITY
<<isdigit>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isdigit
int
_DEFUN(isdigit,(c),int c)
{
return(__ctype_ptr__[c+1] & _N);
}

43
programs/develop/libraries/newlib/ctype/islower.c Normal file
View File

@ -0,0 +1,43 @@
/*
FUNCTION
<<islower>>---lowercase character predicate
INDEX
islower
ANSI_SYNOPSIS
#include <ctype.h>
int islower(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int islower(<[c]>);
DESCRIPTION
<<islower>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for minuscules
(lowercase alphabetic characters), and 0 for other characters.
It is defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef islower>>'.
RETURNS
<<islower>> returns non-zero if <[c]> is a lowercase letter (<<a>>--<<z>>).
PORTABILITY
<<islower>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef islower
int
_DEFUN(islower,(c),int c)
{
return ((__ctype_ptr__[c+1] & (_U|_L)) == _L);
}

60
programs/develop/libraries/newlib/ctype/isprint.c Normal file
View File

@ -0,0 +1,60 @@
/*
FUNCTION
<<isprint>>, <<isgraph>>---printable character predicates
INDEX
isprint
INDEX
isgraph
ANSI_SYNOPSIS
#include <ctype.h>
int isprint(int <[c]>);
int isgraph(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isprint(<[c]>);
int isgraph(<[c]>);
DESCRIPTION
<<isprint>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for printable
characters, and 0 for other character arguments.
It is defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining either macro using `<<#undef isprint>>' or `<<#undef isgraph>>'.
RETURNS
<<isprint>> returns non-zero if <[c]> is a printing character,
(<<0x20>>--<<0x7E>>).
<<isgraph>> behaves identically to <<isprint>>, except that the space
character (<<0x20>>) is excluded.
PORTABILITY
<<isprint>> and <<isgraph>> are ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isgraph
int
_DEFUN(isgraph,(c),int c)
{
return(__ctype_ptr__[c+1] & (_P|_U|_L|_N));
}
#undef isprint
int
_DEFUN(isprint,(c),int c)
{
return(__ctype_ptr__[c+1] & (_P|_U|_L|_N|_B));
}

46
programs/develop/libraries/newlib/ctype/ispunct.c Normal file
View File

@ -0,0 +1,46 @@
/*
FUNCTION
<<ispunct>>---punctuation character predicate
INDEX
ispunct
ANSI_SYNOPSIS
#include <ctype.h>
int ispunct(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int ispunct(<[c]>);
DESCRIPTION
<<ispunct>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for printable
punctuation characters, and 0 for other characters. It is defined
only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef ispunct>>'.
RETURNS
<<ispunct>> returns non-zero if <[c]> is a printable punctuation character
(<<isgraph(<[c]>) && !isalnum(<[c]>)>>).
PORTABILITY
<<ispunct>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef ispunct
int
_DEFUN(ispunct,(c),int c)
{
return(__ctype_ptr__[c+1] & _P);
}

44
programs/develop/libraries/newlib/ctype/isspace.c Normal file
View File

@ -0,0 +1,44 @@
/*
FUNCTION
<<isspace>>---whitespace character predicate
INDEX
isspace
ANSI_SYNOPSIS
#include <ctype.h>
int isspace(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isspace(<[c]>);
DESCRIPTION
<<isspace>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for whitespace
characters, and 0 for other characters. It is defined only when <<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isspace>>'.
RETURNS
<<isspace>> returns non-zero if <[c]> is a space, tab, carriage return, new
line, vertical tab, or formfeed (<<0x09>>--<<0x0D>>, <<0x20>>).
PORTABILITY
<<isspace>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isspace
int
_DEFUN(isspace,(c),int c)
{
return(__ctype_ptr__[c+1] & _S);
}

43
programs/develop/libraries/newlib/ctype/isupper.c Normal file
View File

@ -0,0 +1,43 @@
/*
FUNCTION
<<isupper>>---uppercase character predicate
INDEX
isupper
ANSI_SYNOPSIS
#include <ctype.h>
int isupper(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isupper(<[c]>);
DESCRIPTION
<<isupper>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for uppercase letters
(<<A>>--<<Z>>), and 0 for other characters. It is defined only when
<<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isupper>>'.
RETURNS
<<isupper>> returns non-zero if <[c]> is a uppercase letter (A-Z).
PORTABILITY
<<isupper>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isupper
int
_DEFUN(isupper,(c),int c)
{
return ((__ctype_ptr__[c+1] & (_U|_L)) == _U);
}

37
programs/develop/libraries/newlib/ctype/iswalnum.c Normal file
View File

@ -0,0 +1,37 @@
/*
FUNCTION
<<iswalnum>>---alphanumeric wide character test
INDEX
iswalnum
ANSI_SYNOPSIS
#include <wctype.h>
int iswalnum(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswalnum(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswalnum>> is a function which classifies wide-character values that
are alphanumeric.
RETURNS
<<iswalnum>> returns non-zero if <[c]> is a alphanumeric wide character.
PORTABILITY
<<iswalnum>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswalnum,(c),wint_t c)
{
return (iswalpha (c) || iswdigit (c));
}

433
programs/develop/libraries/newlib/ctype/iswalpha.c Normal file
View File

@ -0,0 +1,433 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswalpha>>---alphabetic wide character test
INDEX
iswalpha
ANSI_SYNOPSIS
#include <wctype.h>
int iswalpha(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswalpha(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswalpha>> is a function which classifies wide-character values that
are alphabetic.
RETURNS
<<iswalpha>> returns non-zero if <[c]> is an alphabetic wide character.
PORTABILITY
<<iswalpha>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <string.h>
#include <ctype.h>
#include "local.h"
#ifdef _MB_CAPABLE
#include "utf8alpha.h"
#endif /* _MB_CAPABLE */
int
_DEFUN(iswalpha,(c), wint_t c)
{
#ifdef _MB_CAPABLE
unsigned const char *table;
unsigned char *ptr;
unsigned char ctmp;
int size;
wint_t x;
c = _jp2uc (c);
/* Based on and tested against Unicode 5.2
See utf8alpha.h for a description how to fetch the data. */
x = (c >> 8);
/* for some large sections, all characters are alphabetic so handle them here */
if ((x >= 0x34 && x <= 0x4c) ||
(x >= 0x4e && x <= 0x9e) ||
(x >= 0xac && x <= 0xd6) ||
(x >= 0x120 && x <= 0x122) ||
(x >= 0x130 && x <= 0x133) ||
(x >= 0x200 && x <= 0x2a5) ||
(x >= 0x2a7 && x <= 0x2b6))
return 1;
switch (x)
{
case 0x00:
table = u0;
size = sizeof(u0);
break;
case 0x01:
case 0x11:
case 0x15:
case 0x1e:
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
case 0xa5:
case 0xf9:
case 0xfc:
case 0x2f8:
case 0x2f9:
return 1;
case 0x02:
table = u2;
size = sizeof(u2);
break;
case 0x03:
table = u3;
size = sizeof(u3);
break;
case 0x04:
table = u4;
size = sizeof(u4);
break;
case 0x05:
table = u5;
size = sizeof(u5);
break;
case 0x06:
table = u6;
size = sizeof(u6);
break;
case 0x07:
table = u7;
size = sizeof(u7);
break;
case 0x08:
table = u8;
size = sizeof(u8);
break;
case 0x09:
table = u9;
size = sizeof(u9);
break;
case 0x0a:
table = ua;
size = sizeof(ua);
break;
case 0x0b:
table = ub;
size = sizeof(ub);
break;
case 0x0c:
table = uc;
size = sizeof(uc);
break;
case 0x0d:
table = ud;
size = sizeof(ud);
break;
case 0x0e:
table = ue;
size = sizeof(ue);
break;
case 0x0f:
table = uf;
size = sizeof(uf);
break;
case 0x10:
table = u10;
size = sizeof(u10);
break;
case 0x12:
table = u12;
size = sizeof(u12);
break;
case 0x13:
table = u13;
size = sizeof(u13);
break;
case 0x14:
table = u14;
size = sizeof(u14);
break;
case 0x16:
table = u16;
size = sizeof(u16);
break;
case 0x17:
table = u17;
size = sizeof(u17);
break;
case 0x18:
table = u18;
size = sizeof(u18);
break;
case 0x19:
table = u19;
size = sizeof(u19);
break;
case 0x1a:
table = u1a;
size = sizeof(u1a);
break;
case 0x1b:
table = u1b;
size = sizeof(u1b);
break;
case 0x1c:
table = u1c;
size = sizeof(u1c);
break;
case 0x1d:
table = u1d;
size = sizeof(u1d);
break;
case 0x1f:
table = u1f;
size = sizeof(u1f);
break;
case 0x20:
table = u20;
size = sizeof(u20);
break;
case 0x21:
table = u21;
size = sizeof(u21);
break;
case 0x24:
table = u24;
size = sizeof(u24);
break;
case 0x2c:
table = u2c;
size = sizeof(u2c);
break;
case 0x2d:
table = u2d;
size = sizeof(u2d);
break;
case 0x2e:
table = u2e;
size = sizeof(u2e);
break;
case 0x30:
table = u30;
size = sizeof(u30);
break;
case 0x31:
table = u31;
size = sizeof(u31);
break;
case 0x4d:
table = u4d;
size = sizeof(u4d);
break;
case 0x9f:
table = u9f;
size = sizeof(u9f);
break;
case 0xa4:
table = ua4;
size = sizeof(ua4);
break;
case 0xa6:
table = ua6;
size = sizeof(ua6);
break;
case 0xa7:
table = ua7;
size = sizeof(ua7);
break;
case 0xa8:
table = ua8;
size = sizeof(ua8);
break;
case 0xa9:
table = ua9;
size = sizeof(ua9);
break;
case 0xaa:
table = uaa;
size = sizeof(uaa);
break;
case 0xab:
table = uab;
size = sizeof(uab);
break;
case 0xd7:
table = ud7;
size = sizeof(ud7);
break;
case 0xfa:
table = ufa;
size = sizeof(ufa);
break;
case 0xfb:
table = ufb;
size = sizeof(ufb);
break;
case 0xfd:
table = ufd;
size = sizeof(ufd);
break;
case 0xfe:
table = ufe;
size = sizeof(ufe);
break;
case 0xff:
table = uff;
size = sizeof(uff);
break;
case 0x100:
table = u100;
size = sizeof(u100);
break;
case 0x101:
table = u101;
size = sizeof(u101);
break;
case 0x102:
table = u102;
size = sizeof(u102);
break;
case 0x103:
table = u103;
size = sizeof(u103);
break;
case 0x104:
table = u104;
size = sizeof(u104);
break;
case 0x108:
table = u108;
size = sizeof(u108);
break;
case 0x109:
table = u109;
size = sizeof(u109);
break;
case 0x10a:
table = u10a;
size = sizeof(u10a);
break;
case 0x10b:
table = u10b;
size = sizeof(u10b);
break;
case 0x10c:
table = u10c;
size = sizeof(u10c);
break;
case 0x110:
table = u110;
size = sizeof(u110);
break;
case 0x123:
table = u123;
size = sizeof(u123);
break;
case 0x124:
table = u124;
size = sizeof(u124);
break;
case 0x134:
table = u134;
size = sizeof(u134);
break;
case 0x1d4:
table = u1d4;
size = sizeof(u1d4);
break;
case 0x1d5:
table = u1d5;
size = sizeof(u1d5);
break;
case 0x1d6:
table = u1d6;
size = sizeof(u1d6);
break;
case 0x1d7:
table = u1d7;
size = sizeof(u1d7);
break;
case 0x1f1:
table = u1f1;
size = sizeof(u1f1);
break;
case 0x2a6:
table = u2a6;
size = sizeof(u2a6);
break;
case 0x2b7:
table = u2b7;
size = sizeof(u2b7);
break;
case 0x2fa:
table = u2fa;
size = sizeof(u2fa);
break;
default:
return 0;
}
/* we have narrowed down to a section of 256 characters to check */
/* now check if c matches the alphabetic wide-chars within that section */
ptr = (unsigned char *)table;
ctmp = (unsigned char)c;
while (ptr < table + size)
{
if (ctmp == *ptr)
return 1;
if (ctmp < *ptr)
return 0;
/* otherwise c > *ptr */
/* look for 0x0 as next element which indicates a range */
++ptr;
if (*ptr == 0x0)
{
/* we have a range..see if c falls within range */
++ptr;
if (ctmp <= *ptr)
return 1;
++ptr;
}
}
/* not in table */
return 0;
#else
return (c < (wint_t)0x100 ? isalpha (c) : 0);
#endif /* _MB_CAPABLE */
}

82
programs/develop/libraries/newlib/ctype/iswblank.c Normal file
View File

@ -0,0 +1,82 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswblank>>---blank wide character test
INDEX
iswblank
ANSI_SYNOPSIS
#include <wctype.h>
int iswblank(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswblank(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswblank>> is a function which classifies wide-character values that
are categorized as blank.
RETURNS
<<iswblank>> returns non-zero if <[c]> is a blank wide character.
PORTABILITY
<<iswblank>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <ctype.h>
#include <string.h>
#include "local.h"
int
_DEFUN(iswblank,(c), wint_t c)
{
#ifdef _MB_CAPABLE
c = _jp2uc (c);
/* Based on Unicode 5.2. Control char 09, plus all characters
from general category "Zs", which are not marked as decomposition
type "noBreak". */
return (c == 0x0009 || c == 0x0020 ||
c == 0x1680 || c == 0x180e ||
(c >= 0x2000 && c <= 0x2006) ||
(c >= 0x2008 && c <= 0x200a) ||
c == 0x205f || c == 0x3000);
#else
return (c < 0x100 ? isblank (c) : 0);
#endif /* _MB_CAPABLE */
}

80
programs/develop/libraries/newlib/ctype/iswcntrl.c Normal file
View File

@ -0,0 +1,80 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswcntrl>>---control wide character test
INDEX
iswcntrl
ANSI_SYNOPSIS
#include <wctype.h>
int iswcntrl(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswcntrl(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswcntrl>> is a function which classifies wide-character values that
are categorized as control characters.
RETURNS
<<iswcntrl>> returns non-zero if <[c]> is a control wide character.
PORTABILITY
<<iswcntrl>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <ctype.h>
#include <string.h>
#include "local.h"
int
_DEFUN(iswcntrl,(c), wint_t c)
{
#ifdef _MB_CAPABLE
c = _jp2uc (c);
/* Based on Unicode 5.2. All characters from general category "Cc", "Zl",
and "Zp". */
return ((c >= 0x0000 && c <= 0x001f) ||
(c >= 0x007f && c <= 0x009f) ||
c == 0x2028 || c == 0x2029);
#else
return (c < 0x100 ? iscntrl (c) : 0);
#endif /* _MB_CAPABLE */
}

71
programs/develop/libraries/newlib/ctype/iswctype.c Normal file
View File

@ -0,0 +1,71 @@
/*
FUNCTION
<<iswctype>>---extensible wide-character test
INDEX
iswctype
ANSI_SYNOPSIS
#include <wctype.h>
int iswctype(wint_t <[c]>, wctype_t <[desc]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswctype(<[c]>, <[desc]>)
wint_t <[c]>;
wctype_t <[desc]>;
DESCRIPTION
<<iswctype>> is a function which classifies wide-character values using the
wide-character test specified by <[desc]>.
RETURNS
<<iswctype>> returns non-zero if and only if <[c]> matches the test specified by <[desc]>.
If <[desc]> is unknown, zero is returned.
PORTABILITY
<<iswctype>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
#include "local.h"
int
_DEFUN(iswctype,(c, desc), wint_t c _AND wctype_t desc)
{
switch (desc)
{
case WC_ALNUM:
return iswalnum (c);
case WC_ALPHA:
return iswalpha (c);
case WC_BLANK:
return iswblank (c);
case WC_CNTRL:
return iswcntrl (c);
case WC_DIGIT:
return iswdigit (c);
case WC_GRAPH:
return iswgraph (c);
case WC_LOWER:
return iswlower (c);
case WC_PRINT:
return iswprint (c);
case WC_PUNCT:
return iswpunct (c);
case WC_SPACE:
return iswspace (c);
case WC_UPPER:
return iswupper (c);
case WC_XDIGIT:
return iswxdigit (c);
default:
return 0; /* eliminate warning */
}
/* otherwise unknown */
return 0;
}

37
programs/develop/libraries/newlib/ctype/iswdigit.c Normal file
View File

@ -0,0 +1,37 @@
/*
FUNCTION
<<iswdigit>>---decimal digit wide character test
INDEX
iswdigit
ANSI_SYNOPSIS
#include <wctype.h>
int iswdigit(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswdigit(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswdigit>> is a function which classifies wide-character values that
are decimal digits.
RETURNS
<<iswdigit>> returns non-zero if <[c]> is a decimal digit wide character.
PORTABILITY
<<iswdigit>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswdigit,(c), wint_t c)
{
return (c >= (wint_t)'0' && c <= (wint_t)'9');
}

66
programs/develop/libraries/newlib/ctype/iswgraph.c Normal file
View File

@ -0,0 +1,66 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswgraph>>---graphic wide character test
INDEX
iswgraph
ANSI_SYNOPSIS
#include <wctype.h>
int iswgraph(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswgraph(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswgraph>> is a function which classifies wide-character values that
are graphic.
RETURNS
<<iswgraph>> returns non-zero if <[c]> is a graphic wide character.
PORTABILITY
<<iswgraph>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswgraph,(c),wint_t c)
{
return (iswprint (c) && !iswspace (c));
}

38
programs/develop/libraries/newlib/ctype/iswlower.c Normal file
View File

@ -0,0 +1,38 @@
/*
FUNCTION
<<iswlower>>---lowercase wide character test
INDEX
iswlower
ANSI_SYNOPSIS
#include <wctype.h>
int iswlower(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswlower(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswlower>> is a function which classifies wide-character values that
have uppercase translations.
RETURNS
<<iswlower>> returns non-zero if <[c]> is a lowercase wide character.
PORTABILITY
<<iswlower>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswlower,(c),wint_t c)
{
return (towupper (c) != c);
}

496
programs/develop/libraries/newlib/ctype/iswprint.c Normal file
View File

@ -0,0 +1,496 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswprint>>---printable wide character test
INDEX
iswprint
ANSI_SYNOPSIS
#include <wctype.h>
int iswprint(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswprint(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswprint>> is a function which classifies wide-character values that
are printable.
RETURNS
<<iswprint>> returns non-zero if <[c]> is a printable wide character.
PORTABILITY
<<iswprint>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <string.h>
#include <ctype.h>
#include "local.h"
#ifdef _MB_CAPABLE
#include "utf8print.h"
#endif /* _MB_CAPABLE */
int
_DEFUN(iswprint,(c), wint_t c)
{
#ifdef _MB_CAPABLE
unsigned const char *table;
unsigned char *ptr;
unsigned char ctmp;
int size;
wint_t x;
c = _jp2uc (c);
/* Based on and tested against Unicode 5.2
See utf8print.h for a description how to fetch the data. */
x = (c >> 8);
/* for some large sections, all characters are printuation so handle them here */
if ((x >= 0x33 && x <= 0x4c) ||
(x >= 0x4e && x <= 0x9e) ||
(x >= 0xa0 && x <= 0xa3) ||
(x >= 0xac && x <= 0xd6) ||
(x >= 0xe0 && x <= 0xf9) ||
(x >= 0x120 && x <= 0x122) ||
(x >= 0x130 && x <= 0x133) ||
(x >= 0x200 && x <= 0x2a5) ||
(x >= 0x2a7 && x <= 0x2b6) ||
(x >= 0xf00 && x <= 0xffe) ||
(x >= 0x1000 && x <= 0x10fe))
return 1;
switch (x)
{
case 0x01:
case 0x02:
case 0x04:
case 0x11:
case 0x14:
case 0x15:
case 0x1e:
case 0x22:
case 0x25:
case 0x28:
case 0x29:
case 0x2a:
case 0xa5:
case 0xfc:
case 0x2f8:
case 0x2f9:
return 1;
case 0x00:
table = u0;
size = sizeof(u0);
break;
case 0x03:
table = u3;
size = sizeof(u3);
break;
case 0x05:
table = u5;
size = sizeof(u5);
break;
case 0x06:
table = u6;
size = sizeof(u6);
break;
case 0x07:
table = u7;
size = sizeof(u7);
break;
case 0x08:
table = u8;
size = sizeof(u8);
break;
case 0x09:
table = u9;
size = sizeof(u9);
break;
case 0x0a:
table = ua;
size = sizeof(ua);
break;
case 0x0b:
table = ub;
size = sizeof(ub);
break;
case 0x0c:
table = uc;
size = sizeof(uc);
break;
case 0x0d:
table = ud;
size = sizeof(ud);
break;
case 0x0e:
table = ue;
size = sizeof(ue);
break;
case 0x0f:
table = uf;
size = sizeof(uf);
break;
case 0x10:
table = u10;
size = sizeof(u10);
break;
case 0x12:
table = u12;
size = sizeof(u12);
break;
case 0x13:
table = u13;
size = sizeof(u13);
break;
case 0x16:
table = u16;
size = sizeof(u16);
break;
case 0x17:
table = u17;
size = sizeof(u17);
break;
case 0x18:
table = u18;
size = sizeof(u18);
break;
case 0x19:
table = u19;
size = sizeof(u19);
break;
case 0x1a:
table = u1a;
size = sizeof(u1a);
break;
case 0x1b:
table = u1b;
size = sizeof(u1b);
break;
case 0x1c:
table = u1c;
size = sizeof(u1c);
break;
case 0x1d:
table = u1d;
size = sizeof(u1d);
break;
case 0x1f:
table = u1f;
size = sizeof(u1f);
break;
case 0x20:
table = u20;
size = sizeof(u20);
break;
case 0x21:
table = u21;
size = sizeof(u21);
break;
case 0x23:
table = u23;
size = sizeof(u23);
break;
case 0x24:
table = u24;
size = sizeof(u24);
break;
case 0x26:
table = u26;
size = sizeof(u26);
break;
case 0x27:
table = u27;
size = sizeof(u27);
break;
case 0x2b:
table = u2b;
size = sizeof(u2b);
break;
case 0x2c:
table = u2c;
size = sizeof(u2c);
break;
case 0x2d:
table = u2d;
size = sizeof(u2d);
break;
case 0x2e:
table = u2e;
size = sizeof(u2e);
break;
case 0x2f:
table = u2f;
size = sizeof(u2f);
break;
case 0x30:
table = u30;
size = sizeof(u30);
break;
case 0x31:
table = u31;
size = sizeof(u31);
break;
case 0x32:
table = u32;
size = sizeof(u32);
break;
case 0x4d:
table = u4d;
size = sizeof(u4d);
break;
case 0x9f:
table = u9f;
size = sizeof(u9f);
break;
case 0xa4:
table = ua4;
size = sizeof(ua4);
break;
case 0xa6:
table = ua6;
size = sizeof(ua6);
break;
case 0xa7:
table = ua7;
size = sizeof(ua7);
break;
case 0xa8:
table = ua8;
size = sizeof(ua8);
break;
case 0xa9:
table = ua9;
size = sizeof(ua9);
break;
case 0xaa:
table = uaa;
size = sizeof(uaa);
break;
case 0xab:
table = uab;
size = sizeof(uab);
break;
case 0xd7:
table = ud7;
size = sizeof(ud7);
break;
case 0xfa:
table = ufa;
size = sizeof(ufa);
break;
case 0xfb:
table = ufb;
size = sizeof(ufb);
break;
case 0xfd:
table = ufd;
size = sizeof(ufd);
break;
case 0xfe:
table = ufe;
size = sizeof(ufe);
break;
case 0xff:
table = uff;
size = sizeof(uff);
break;
case 0x100:
table = u100;
size = sizeof(u100);
break;
case 0x101:
table = u101;
size = sizeof(u101);
break;
case 0x102:
table = u102;
size = sizeof(u102);
break;
case 0x103:
table = u103;
size = sizeof(u103);
break;
case 0x104:
table = u104;
size = sizeof(u104);
break;
case 0x108:
table = u108;
size = sizeof(u108);
break;
case 0x109:
table = u109;
size = sizeof(u109);
break;
case 0x10a:
table = u10a;
size = sizeof(u10a);
break;
case 0x10b:
table = u10b;
size = sizeof(u10b);
break;
case 0x10c:
table = u10c;
size = sizeof(u10c);
break;
case 0x10e:
table = u10e;
size = sizeof(u10e);
break;
case 0x110:
table = u110;
size = sizeof(u110);
break;
case 0x123:
table = u123;
size = sizeof(u123);
break;
case 0x124:
table = u124;
size = sizeof(u124);
break;
case 0x134:
table = u134;
size = sizeof(u134);
break;
case 0x1d0:
table = u1d0;
size = sizeof(u1d0);
break;
case 0x1d1:
table = u1d1;
size = sizeof(u1d1);
break;
case 0x1d2:
table = u1d2;
size = sizeof(u1d2);
break;
case 0x1d3:
table = u1d3;
size = sizeof(u1d3);
break;
case 0x1d4:
table = u1d4;
size = sizeof(u1d4);
break;
case 0x1d5:
table = u1d5;
size = sizeof(u1d5);
break;
case 0x1d6:
table = u1d6;
size = sizeof(u1d6);
break;
case 0x1d7:
table = u1d7;
size = sizeof(u1d7);
break;
case 0x1f0:
table = u1f0;
size = sizeof(u1f0);
break;
case 0x1f1:
table = u1f1;
size = sizeof(u1f1);
break;
case 0x1f2:
table = u1f2;
size = sizeof(u1f2);
break;
case 0x2a6:
table = u2a6;
size = sizeof(u2a6);
break;
case 0x2b7:
table = u2b7;
size = sizeof(u2b7);
break;
case 0x2fa:
table = u2fa;
size = sizeof(u2fa);
break;
case 0xe00:
table = ue00;
size = sizeof(ue00);
break;
case 0xe01:
table = ue01;
size = sizeof(ue01);
break;
case 0xfff:
table = ufff;
size = sizeof(ufff);
break;
case 0x10ff:
table = u10ff;
size = sizeof(u10ff);
break;
default:
return 0;
}
/* we have narrowed down to a section of 256 characters to check */
/* now check if c matches the printuation wide-chars within that section */
ptr = (unsigned char *)table;
ctmp = (unsigned char)c;
while (ptr < table + size)
{
if (ctmp == *ptr)
return 1;
if (ctmp < *ptr)
return 0;
/* otherwise c > *ptr */
/* look for 0x0 as next element which indicates a range */
++ptr;
if (*ptr == 0x0)
{
/* we have a range..see if c falls within range */
++ptr;
if (ctmp <= *ptr)
return 1;
++ptr;
}
}
/* not in table */
return 0;
#else
return (c < (wint_t)0x100 ? isprint (c) : 0);
#endif /* _MB_CAPABLE */
}

70
programs/develop/libraries/newlib/ctype/iswpunct.c Normal file
View File

@ -0,0 +1,70 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswpunct>>---punctuation wide character test
INDEX
iswpunct
ANSI_SYNOPSIS
#include <wctype.h>
int iswpunct(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswpunct(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswpunct>> is a function which classifies wide-character values that
are punctuation.
RETURNS
<<iswpunct>> returns non-zero if <[c]> is a punctuation wide character.
PORTABILITY
<<iswpunct>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <string.h>
#include <ctype.h>
#include "local.h"
int
_DEFUN(iswpunct,(c), wint_t c)
{
return (!iswalnum (c) && iswgraph (c));
}

83
programs/develop/libraries/newlib/ctype/iswspace.c Normal file
View File

@ -0,0 +1,83 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<iswspace>>---whitespace wide character test
INDEX
iswspace
ANSI_SYNOPSIS
#include <wctype.h>
int iswspace(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswspace(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswspace>> is a function which classifies wide-character values that
are categorized as whitespace.
RETURNS
<<iswspace>> returns non-zero if <[c]> is a whitespace wide character.
PORTABILITY
<<iswspace>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <wctype.h>
#include <ctype.h>
#include <string.h>
#include "local.h"
int
_DEFUN(iswspace,(c), wint_t c)
{
#ifdef _MB_CAPABLE
c = _jp2uc (c);
/* Based on Unicode 5.2. Control chars 09-0D, plus all characters
from general category "Zs", which are not marked as decomposition
type "noBreak". */
return ((c >= 0x0009 && c <= 0x000d) || c == 0x0020 ||
c == 0x1680 || c == 0x180e ||
(c >= 0x2000 && c <= 0x2006) ||
(c >= 0x2008 && c <= 0x200a) ||
c == 0x2028 || c == 0x2029 ||
c == 0x205f || c == 0x3000);
#else
return (c < 0x100 ? isspace (c) : 0);
#endif /* _MB_CAPABLE */
}

38
programs/develop/libraries/newlib/ctype/iswupper.c Normal file
View File

@ -0,0 +1,38 @@
/*
FUNCTION
<<iswupper>>---uppercase wide character test
INDEX
iswupper
ANSI_SYNOPSIS
#include <wctype.h>
int iswupper(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswupper(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswupper>> is a function which classifies wide-character values that
have uppercase translations.
RETURNS
<<iswupper>> returns non-zero if <[c]> is a uppercase wide character.
PORTABILITY
<<iswupper>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswupper,(c),wint_t c)
{
return (towlower (c) != c);
}

39
programs/develop/libraries/newlib/ctype/iswxdigit.c Normal file
View File

@ -0,0 +1,39 @@
/*
FUNCTION
<<iswxdigit>>---hexadecimal digit wide character test
INDEX
iswxdigit
ANSI_SYNOPSIS
#include <wctype.h>
int iswxdigit(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
int iswxdigit(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<iswxdigit>> is a function which classifies wide character values that
are hexadecimal digits.
RETURNS
<<iswxdigit>> returns non-zero if <[c]> is a hexadecimal digit wide character.
PORTABILITY
<<iswxdigit>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <wctype.h>
int
_DEFUN(iswxdigit,(c), wint_t c)
{
return ((c >= (wint_t)'0' && c <= (wint_t)'9') ||
(c >= (wint_t)'a' && c <= (wint_t)'f') ||
(c >= (wint_t)'A' && c <= (wint_t)'F'));
}

45
programs/develop/libraries/newlib/ctype/isxdigit.c Normal file
View File

@ -0,0 +1,45 @@
/*
FUNCTION
<<isxdigit>>---hexadecimal digit predicate
INDEX
isxdigit
ANSI_SYNOPSIS
#include <ctype.h>
int isxdigit(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int isxdigit(int <[c]>);
DESCRIPTION
<<isxdigit>> is a macro which classifies ASCII integer values by table
lookup. It is a predicate returning non-zero for hexadecimal digits,
and <<0>> for other characters. It is defined only when
<<isascii>>(<[c]>) is true or <[c]> is EOF.
You can use a compiled subroutine instead of the macro definition by
undefining the macro using `<<#undef isxdigit>>'.
RETURNS
<<isxdigit>> returns non-zero if <[c]> is a hexadecimal digit
(<<0>>--<<9>>, <<a>>--<<f>>, or <<A>>--<<F>>).
PORTABILITY
<<isxdigit>> is ANSI C.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#undef isxdigit
int
_DEFUN(isxdigit,(c),int c)
{
return(__ctype_ptr__[c+1] & ((_X)|(_N)));
}

6849
programs/develop/libraries/newlib/ctype/jp2uc.h Normal file
View File

File diff suppressed because it is too large Load Diff

32
programs/develop/libraries/newlib/ctype/local.h Normal file
View File

@ -0,0 +1,32 @@
/* wctrans constants */
#include <_ansi.h>
/* valid values for wctrans_t */
#define WCT_TOLOWER 1
#define WCT_TOUPPER 2
/* valid values for wctype_t */
#define WC_ALNUM 1
#define WC_ALPHA 2
#define WC_BLANK 3
#define WC_CNTRL 4
#define WC_DIGIT 5
#define WC_GRAPH 6
#define WC_LOWER 7
#define WC_PRINT 8
#define WC_PUNCT 9
#define WC_SPACE 10
#define WC_UPPER 11
#define WC_XDIGIT 12
extern char *__locale_charset(_NOARGS);
/* internal function to translate JP to Unicode */
#ifdef __CYGWIN__
/* Under Cygwin, the incoming wide character is already given in UTF due
to the requirements of the underlying OS. */
#define _jp2uc(c) (c)
#else
wint_t _EXFUN (_jp2uc, (wint_t));
#endif

76
programs/develop/libraries/newlib/ctype/tolower.c Normal file
View File

@ -0,0 +1,76 @@
/*
FUNCTION
<<tolower>>---translate characters to lowercase
INDEX
tolower
INDEX
_tolower
ANSI_SYNOPSIS
#include <ctype.h>
int tolower(int <[c]>);
int _tolower(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int tolower(<[c]>);
int _tolower(<[c]>);
DESCRIPTION
<<tolower>> is a macro which converts uppercase characters to lowercase,
leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>.
You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef tolower>>'.
<<_tolower>> performs the same conversion as <<tolower>>, but should
only be used when <[c]> is known to be an uppercase character (<<A>>--<<Z>>).
RETURNS
<<tolower>> returns the lowercase equivalent of <[c]> when it is a
character between <<A>> and <<Z>>, and <[c]> otherwise.
<<_tolower>> returns the lowercase equivalent of <[c]> when it is a
character between <<A>> and <<Z>>. If <[c]> is not one of these
characters, the behaviour of <<_tolower>> is undefined.
PORTABILITY
<<tolower>> is ANSI C. <<_tolower>> is not recommended for portable
programs.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS)
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <wctype.h>
#include <wchar.h>
#endif
#undef tolower
int
_DEFUN(tolower,(c),int c)
{
#if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS)
if ((unsigned char) c <= 0x7f)
return isupper (c) ? c - 'A' + 'a' : c;
else if (c != EOF && MB_CUR_MAX == 1 && isupper (c))
{
char s[MB_LEN_MAX] = { c, '\0' };
wchar_t wc;
if (mbtowc (&wc, s, 1) >= 0
&& wctomb (s, (wchar_t) towlower ((wint_t) wc)) == 1)
c = (unsigned char) s[0];
}
return c;
#else
return isupper(c) ? (c) - 'A' + 'a' : c;
#endif
}

75
programs/develop/libraries/newlib/ctype/toupper.c Normal file
View File

@ -0,0 +1,75 @@
/*
FUNCTION
<<toupper>>---translate characters to uppercase
INDEX
toupper
INDEX
_toupper
ANSI_SYNOPSIS
#include <ctype.h>
int toupper(int <[c]>);
int _toupper(int <[c]>);
TRAD_SYNOPSIS
#include <ctype.h>
int toupper(<[c]>);
int _toupper(<[c]>);
DESCRIPTION
<<toupper>> is a macro which converts lowercase characters to uppercase,
leaving all other characters unchanged. It is only defined when
<[c]> is an integer in the range <<EOF>> to <<255>>.
You can use a compiled subroutine instead of the macro definition by
undefining this macro using `<<#undef toupper>>'.
<<_toupper>> performs the same conversion as <<toupper>>, but should
only be used when <[c]> is known to be a lowercase character (<<a>>--<<z>>).
RETURNS
<<toupper>> returns the uppercase equivalent of <[c]> when it is a
character between <<a>> and <<z>>, and <[c]> otherwise.
<<_toupper>> returns the uppercase equivalent of <[c]> when it is a
character between <<a>> and <<z>>. If <[c]> is not one of these
characters, the behaviour of <<_toupper>> is undefined.
PORTABILITY
<<toupper>> is ANSI C. <<_toupper>> is not recommended for portable programs.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <ctype.h>
#if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS)
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <wctype.h>
#include <wchar.h>
#endif
#undef toupper
int
_DEFUN(toupper,(c),int c)
{
#if defined (_MB_EXTENDED_CHARSETS_ISO) || defined (_MB_EXTENDED_CHARSETS_WINDOWS)
if ((unsigned char) c <= 0x7f)
return islower (c) ? c - 'a' + 'A' : c;
else if (c != EOF && MB_CUR_MAX == 1 && islower (c))
{
char s[MB_LEN_MAX] = { c, '\0' };
wchar_t wc;
if (mbtowc (&wc, s, 1) >= 0
&& wctomb (s, (wchar_t) towupper ((wint_t) wc)) == 1)
c = (unsigned char) s[0];
}
return c;
#else
return islower (c) ? c - 'a' + 'A' : c;
#endif
}

569
programs/develop/libraries/newlib/ctype/towlower.c Normal file
View File

@ -0,0 +1,569 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<towlower>>---translate wide characters to lowercase
INDEX
towlower
ANSI_SYNOPSIS
#include <wctype.h>
wint_t towlower(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
wint_t towlower(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<towlower>> is a function which converts uppercase wide characters to
lowercase, leaving all other characters unchanged.
RETURNS
<<towlower>> returns the lowercase equivalent of <[c]> when it is a
uppercase wide character; otherwise, it returns the input character.
PORTABILITY
<<towlower>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <string.h>
#include <reent.h>
#include <ctype.h>
#include <wctype.h>
#include "local.h"
wint_t
_DEFUN(towlower,(c), wint_t c)
{
#ifdef _MB_CAPABLE
c = _jp2uc (c);
/* Based on and tested against Unicode 5.2 */
/* Expression used to filter out the characters for the below code:
awk -F\; '{ if ( $14 != "" ) print $1; }' UnicodeData.txt
*/
if (c < 0x100)
{
if ((c >= 0x0041 && c <= 0x005a) ||
(c >= 0x00c0 && c <= 0x00d6) ||
(c >= 0x00d8 && c <= 0x00de))
return (c + 0x20);
return c;
}
else if (c < 0x300)
{
if ((c >= 0x0100 && c <= 0x012e) ||
(c >= 0x0132 && c <= 0x0136) ||
(c >= 0x014a && c <= 0x0176) ||
(c >= 0x01de && c <= 0x01ee) ||
(c >= 0x01f8 && c <= 0x021e) ||
(c >= 0x0222 && c <= 0x0232))
{
if (!(c & 0x01))
return (c + 1);
return c;
}
if (c == 0x0130)
return 0x0069;
if ((c >= 0x0139 && c <= 0x0147) ||
(c >= 0x01cd && c <= 0x01db))
{
if (c & 0x01)
return (c + 1);
return c;
}
if (c >= 0x178 && c <= 0x01f7)
{
wint_t k;
switch (c)
{
case 0x0178:
k = 0x00ff;
break;
case 0x0179:
case 0x017b:
case 0x017d:
case 0x0182:
case 0x0184:
case 0x0187:
case 0x018b:
case 0x0191:
case 0x0198:
case 0x01a0:
case 0x01a2:
case 0x01a4:
case 0x01a7:
case 0x01ac:
case 0x01af:
case 0x01b3:
case 0x01b5:
case 0x01b8:
case 0x01bc:
case 0x01c5:
case 0x01c8:
case 0x01cb:
case 0x01cd:
case 0x01cf:
case 0x01d1:
case 0x01d3:
case 0x01d5:
case 0x01d7:
case 0x01d9:
case 0x01db:
case 0x01f2:
case 0x01f4:
k = c + 1;
break;
case 0x0181:
k = 0x0253;
break;
case 0x0186:
k = 0x0254;
break;
case 0x0189:
k = 0x0256;
break;
case 0x018a:
k = 0x0257;
break;
case 0x018e:
k = 0x01dd;
break;
case 0x018f:
k = 0x0259;
break;
case 0x0190:
k = 0x025b;
break;
case 0x0193:
k = 0x0260;
break;
case 0x0194:
k = 0x0263;
break;
case 0x0196:
k = 0x0269;
break;
case 0x0197:
k = 0x0268;
break;
case 0x019c:
k = 0x026f;
break;
case 0x019d:
k = 0x0272;
break;
case 0x019f:
k = 0x0275;
break;
case 0x01a6:
k = 0x0280;
break;
case 0x01a9:
k = 0x0283;
break;
case 0x01ae:
k = 0x0288;
break;
case 0x01b1:
k = 0x028a;
break;
case 0x01b2:
k = 0x028b;
break;
case 0x01b7:
k = 0x0292;
break;
case 0x01c4:
case 0x01c7:
case 0x01ca:
case 0x01f1:
k = c + 2;
break;
case 0x01f6:
k = 0x0195;
break;
case 0x01f7:
k = 0x01bf;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
else if (c == 0x0220)
return 0x019e;
else if (c >= 0x023a && c <= 0x024e)
{
wint_t k;
switch (c)
{
case 0x023a:
k = 0x2c65;
break;
case 0x023b:
case 0x0241:
case 0x0246:
case 0x0248:
case 0x024a:
case 0x024c:
case 0x024e:
k = c + 1;
break;
case 0x023d:
k = 0x019a;
break;
case 0x023e:
k = 0x2c66;
break;
case 0x0243:
k = 0x0180;
break;
case 0x0244:
k = 0x0289;
break;
case 0x0245:
k = 0x028c;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
}
else if (c < 0x0400)
{
if (c == 0x0370 || c == 0x0372 || c == 0x0376)
return (c + 1);
if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)
return (c + 0x20);
if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))
return (c + 1);
if (c >= 0x0386 && c <= 0x03ff)
{
wint_t k;
switch (c)
{
case 0x0386:
k = 0x03ac;
break;
case 0x0388:
k = 0x03ad;
break;
case 0x0389:
k = 0x03ae;
break;
case 0x038a:
k = 0x03af;
break;
case 0x038c:
k = 0x03cc;
break;
case 0x038e:
k = 0x03cd;
break;
case 0x038f:
k = 0x03ce;
break;
case 0x03cf:
k = 0x03d7;
break;
case 0x03f4:
k = 0x03b8;
break;
case 0x03f7:
k = 0x03f8;
break;
case 0x03f9:
k = 0x03f2;
break;
case 0x03fa:
k = 0x03fb;
break;
case 0x03fd:
k = 0x037b;
break;
case 0x03fe:
k = 0x037c;
break;
case 0x03ff:
k = 0x037d;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
}
else if (c < 0x500)
{
if (c >= 0x0400 && c <= 0x040f)
return (c + 0x50);
if (c >= 0x0410 && c <= 0x042f)
return (c + 0x20);
if ((c >= 0x0460 && c <= 0x0480) ||
(c >= 0x048a && c <= 0x04be) ||
(c >= 0x04d0 && c <= 0x04fe))
{
if (!(c & 0x01))
return (c + 1);
return c;
}
if (c == 0x04c0)
return 0x04cf;
if (c >= 0x04c1 && c <= 0x04cd)
{
if (c & 0x01)
return (c + 1);
return c;
}
}
else if (c < 0x1f00)
{
if ((c >= 0x0500 && c <= 0x050e) ||
(c >= 0x0510 && c <= 0x0524) ||
(c >= 0x1e00 && c <= 0x1e94) ||
(c >= 0x1ea0 && c <= 0x1ef8))
{
if (!(c & 0x01))
return (c + 1);
return c;
}
if (c >= 0x0531 && c <= 0x0556)
return (c + 0x30);
if (c >= 0x10a0 && c <= 0x10c5)
return (c + 0x1c60);
if (c == 0x1e9e)
return 0x00df;
if (c >= 0x1efa && c <= 0x1efe && !(c & 0x01))
return (c + 1);
}
else if (c < 0x2000)
{
if ((c >= 0x1f08 && c <= 0x1f0f) ||
(c >= 0x1f18 && c <= 0x1f1d) ||
(c >= 0x1f28 && c <= 0x1f2f) ||
(c >= 0x1f38 && c <= 0x1f3f) ||
(c >= 0x1f48 && c <= 0x1f4d) ||
(c >= 0x1f68 && c <= 0x1f6f) ||
(c >= 0x1f88 && c <= 0x1f8f) ||
(c >= 0x1f98 && c <= 0x1f9f) ||
(c >= 0x1fa8 && c <= 0x1faf))
return (c - 0x08);
if (c >= 0x1f59 && c <= 0x1f5f)
{
if (c & 0x01)
return (c - 0x08);
return c;
}
if (c >= 0x1fb8 && c <= 0x1ffc)
{
wint_t k;
switch (c)
{
case 0x1fb8:
case 0x1fb9:
case 0x1fd8:
case 0x1fd9:
case 0x1fe8:
case 0x1fe9:
k = c - 0x08;
break;
case 0x1fba:
case 0x1fbb:
k = c - 0x4a;
break;
case 0x1fbc:
k = 0x1fb3;
break;
case 0x1fc8:
case 0x1fc9:
case 0x1fca:
case 0x1fcb:
k = c - 0x56;
break;
case 0x1fcc:
k = 0x1fc3;
break;
case 0x1fda:
case 0x1fdb:
k = c - 0x64;
break;
case 0x1fea:
case 0x1feb:
k = c - 0x70;
break;
case 0x1fec:
k = 0x1fe5;
break;
case 0x1ff8:
case 0x1ff9:
k = c - 0x80;
break;
case 0x1ffa:
case 0x1ffb:
k = c - 0x7e;
break;
case 0x1ffc:
k = 0x1ff3;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
}
else if (c < 0x2c00)
{
if (c >= 0x2160 && c <= 0x216f)
return (c + 0x10);
if (c >= 0x24b6 && c <= 0x24cf)
return (c + 0x1a);
switch (c)
{
case 0x2126:
return 0x03c9;
case 0x212a:
return 0x006b;
case 0x212b:
return 0x00e5;
case 0x2132:
return 0x214e;
case 0x2183:
return 0x2184;
}
}
else if (c < 0x2d00)
{
if (c >= 0x2c00 && c <= 0x2c2e)
return (c + 0x30);
if (c >= 0x2c80 && c <= 0x2ce2 && !(c & 0x01))
return (c + 1);
switch (c)
{
case 0x2c60:
return 0x2c61;
case 0x2c62:
return 0x026b;
case 0x2c63:
return 0x1d7d;
case 0x2c64:
return 0x027d;
case 0x2c67:
case 0x2c69:
case 0x2c6b:
case 0x2c72:
case 0x2c75:
case 0x2ceb:
case 0x2ced:
return c + 1;
case 0x2c6d:
return 0x0251;
case 0x2c6e:
return 0x0271;
case 0x2c6f:
return 0x0250;
case 0x2c70:
return 0x0252;
case 0x2c7e:
return 0x023f;
case 0x2c7f:
return 0x0240;
}
}
else if (c >= 0xa600 && c < 0xa800)
{
if ((c >= 0xa640 && c <= 0xa65e) ||
(c >= 0xa662 && c <= 0xa66c) ||
(c >= 0xa680 && c <= 0xa696) ||
(c >= 0xa722 && c <= 0xa72e) ||
(c >= 0xa732 && c <= 0xa76e) ||
(c >= 0xa77f && c <= 0xa786))
{
if (!(c & 1))
return (c + 1);
return c;
}
switch (c)
{
case 0xa779:
case 0xa77b:
case 0xa77e:
case 0xa78b:
return (c + 1);
case 0xa77d:
return 0x1d79;
}
}
else
{
if (c >= 0xff21 && c <= 0xff3a)
return (c + 0x20);
if (c >= 0x10400 && c <= 0x10427)
return (c + 0x28);
}
return c;
#else
return (c < 0x00ff ? (wint_t)(tolower ((int)c)) : c);
#endif /* _MB_CAPABLE */
}

590
programs/develop/libraries/newlib/ctype/towupper.c Normal file
View File

@ -0,0 +1,590 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/*
FUNCTION
<<towupper>>---translate wide characters to uppercase
INDEX
towupper
ANSI_SYNOPSIS
#include <wctype.h>
wint_t towupper(wint_t <[c]>);
TRAD_SYNOPSIS
#include <wctype.h>
wint_t towupper(<[c]>)
wint_t <[c]>;
DESCRIPTION
<<towupper>> is a function which converts lowercase wide characters to
uppercase, leaving all other characters unchanged.
RETURNS
<<towupper>> returns the uppercase equivalent of <[c]> when it is a
lowercase wide character, otherwise, it returns the input character.
PORTABILITY
<<towupper>> is C99.
No supporting OS subroutines are required.
*/
#include <_ansi.h>
#include <newlib.h>
#include <string.h>
#include <reent.h>
#include <ctype.h>
#include <wctype.h>
#include "local.h"
wint_t
_DEFUN(towupper,(c), wint_t c)
{
#ifdef _MB_CAPABLE
c = _jp2uc (c);
/* Based on and tested against Unicode 5.2 */
/* Expression used to filter out the characters for the below code:
awk -F\; '{ if ( $13 != "" ) print $1; }' UnicodeData.txt
*/
if (c < 0x100)
{
if (c == 0x00b5)
return 0x039c;
if ((c >= 0x00e0 && c <= 0x00fe && c != 0x00f7) ||
(c >= 0x0061 && c <= 0x007a))
return (c - 0x20);
if (c == 0xff)
return 0x0178;
return c;
}
else if (c < 0x300)
{
if ((c >= 0x0101 && c <= 0x012f) ||
(c >= 0x0133 && c <= 0x0137) ||
(c >= 0x014b && c <= 0x0177) ||
(c >= 0x01df && c <= 0x01ef) ||
(c >= 0x01f9 && c <= 0x021f) ||
(c >= 0x0223 && c <= 0x0233) ||
(c >= 0x0247 && c <= 0x024f))
{
if (c & 0x01)
return (c - 1);
return c;
}
if ((c >= 0x013a && c <= 0x0148) ||
(c >= 0x01ce && c <= 0x01dc) ||
c == 0x023c || c == 0x0242)
{
if (!(c & 0x01))
return (c - 1);
return c;
}
if (c == 0x0131)
return 0x0049;
if (c == 0x017a || c == 0x017c || c == 0x017e)
return (c - 1);
if (c >= 0x017f && c <= 0x0292)
{
wint_t k;
switch (c)
{
case 0x017f:
k = 0x0053;
break;
case 0x0180:
k = 0x0243;
break;
case 0x0183:
k = 0x0182;
break;
case 0x0185:
k = 0x0184;
break;
case 0x0188:
k = 0x0187;
break;
case 0x018c:
k = 0x018b;
break;
case 0x0192:
k = 0x0191;
break;
case 0x0195:
k = 0x01f6;
break;
case 0x0199:
k = 0x0198;
break;
case 0x019a:
k = 0x023d;
break;
case 0x019e:
k = 0x0220;
break;
case 0x01a1:
case 0x01a3:
case 0x01a5:
case 0x01a8:
case 0x01ad:
case 0x01b0:
case 0x01b4:
case 0x01b6:
case 0x01b9:
case 0x01bd:
case 0x01c5:
case 0x01c8:
case 0x01cb:
case 0x01f2:
case 0x01f5:
k = c - 1;
break;
case 0x01bf:
k = 0x01f7;
break;
case 0x01c6:
case 0x01c9:
case 0x01cc:
k = c - 2;
break;
case 0x01dd:
k = 0x018e;
break;
case 0x01f3:
k = 0x01f1;
break;
case 0x023f:
k = 0x2c7e;
break;
case 0x0240:
k = 0x2c7f;
break;
case 0x0250:
k = 0x2c6f;
break;
case 0x0251:
k = 0x2c6d;
break;
case 0x0252:
k = 0x2c70;
break;
case 0x0253:
k = 0x0181;
break;
case 0x0254:
k = 0x0186;
break;
case 0x0256:
k = 0x0189;
break;
case 0x0257:
k = 0x018a;
break;
case 0x0259:
k = 0x018f;
break;
case 0x025b:
k = 0x0190;
break;
case 0x0260:
k = 0x0193;
break;
case 0x0263:
k = 0x0194;
break;
case 0x0268:
k = 0x0197;
break;
case 0x0269:
k = 0x0196;
break;
case 0x026b:
k = 0x2c62;
break;
case 0x026f:
k = 0x019c;
break;
case 0x0271:
k = 0x2c6e;
break;
case 0x0272:
k = 0x019d;
break;
case 0x0275:
k = 0x019f;
break;
case 0x027d:
k = 0x2c64;
break;
case 0x0280:
k = 0x01a6;
break;
case 0x0283:
k = 0x01a9;
break;
case 0x0288:
k = 0x01ae;
break;
case 0x0289:
k = 0x0244;
break;
case 0x028a:
k = 0x01b1;
break;
case 0x028b:
k = 0x01b2;
break;
case 0x028c:
k = 0x0245;
break;
case 0x0292:
k = 0x01b7;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
}
else if (c < 0x0400)
{
wint_t k;
if (c >= 0x03ad && c <= 0x03af)
return (c - 0x25);
if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
return (c - 0x20);
if (c >= 0x03d9 && c <= 0x03ef && (c & 1))
return (c - 1);
switch (c)
{
case 0x0345:
k = 0x0399;
break;
case 0x0371:
case 0x0373:
case 0x0377:
case 0x03f8:
case 0x03fb:
k = c - 1;
break;
case 0x037b:
case 0x037c:
case 0x037d:
k = c + 0x82;
break;
case 0x03ac:
k = 0x0386;
break;
case 0x03c2:
k = 0x03a3;
break;
case 0x03cc:
k = 0x038c;
break;
case 0x03cd:
case 0x03ce:
k = c - 0x3f;
break;
case 0x03d0:
k = 0x0392;
break;
case 0x03d1:
k = 0x0398;
break;
case 0x03d5:
k = 0x03a6;
break;
case 0x03d6:
k = 0x03a0;
break;
case 0x03d7:
k = 0x03cf;
break;
case 0x03f0:
k = 0x039a;
break;
case 0x03f1:
k = 0x03a1;
break;
case 0x03f2:
k = 0x03f9;
break;
case 0x03f5:
k = 0x0395;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
else if (c < 0x500)
{
if (c >= 0x0430 && c <= 0x044f)
return (c - 0x20);
if (c >= 0x0450 && c <= 0x045f)
return (c - 0x50);
if ((c >= 0x0461 && c <= 0x0481) ||
(c >= 0x048b && c <= 0x04bf) ||
(c >= 0x04d1 && c <= 0x04ff))
{
if (c & 0x01)
return (c - 1);
return c;
}
if (c >= 0x04c2 && c <= 0x04ce)
{
if (!(c & 0x01))
return (c - 1);
return c;
}
if (c == 0x04cf)
return 0x04c0;
if (c >= 0x04f7 && c <= 0x04f9)
return (c - 1);
}
else if (c < 0x0600)
{
if (c >= 0x0501 && c <= 0x0525 && (c & 1))
return c - 1;
if (c >= 0x0561 && c <= 0x0586)
return (c - 0x30);
}
else if (c < 0x1f00)
{
if (c == 0x1d79)
return 0xa77d;
if (c == 0x1d7d)
return 0x2c63;
if ((c >= 0x1e01 && c <= 0x1e95) ||
(c >= 0x1ea1 && c <= 0x1eff))
{
if (c & 0x01)
return (c - 1);
return c;
}
if (c == 0x1e9b)
return 0x1e60;
}
else if (c < 0x2000)
{
if ((c >= 0x1f00 && c <= 0x1f07) ||
(c >= 0x1f10 && c <= 0x1f15) ||
(c >= 0x1f20 && c <= 0x1f27) ||
(c >= 0x1f30 && c <= 0x1f37) ||
(c >= 0x1f40 && c <= 0x1f45) ||
(c >= 0x1f60 && c <= 0x1f67) ||
(c >= 0x1f80 && c <= 0x1f87) ||
(c >= 0x1f90 && c <= 0x1f97) ||
(c >= 0x1fa0 && c <= 0x1fa7))
return (c + 0x08);
if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
return (c + 0x08);
if (c >= 0x1f70 && c <= 0x1ff3)
{
wint_t k;
switch (c)
{
case 0x1fb0:
k = 0x1fb8;
break;
case 0x1fb1:
k = 0x1fb9;
break;
case 0x1f70:
k = 0x1fba;
break;
case 0x1f71:
k = 0x1fbb;
break;
case 0x1fb3:
k = 0x1fbc;
break;
case 0x1fbe:
k = 0x0399;
break;
case 0x1f72:
k = 0x1fc8;
break;
case 0x1f73:
k = 0x1fc9;
break;
case 0x1f74:
k = 0x1fca;
break;
case 0x1f75:
k = 0x1fcb;
break;
case 0x1fc3:
k = 0x1fcc;
break;
case 0x1fd0:
k = 0x1fd8;
break;
case 0x1fd1:
k = 0x1fd9;
break;
case 0x1f76:
k = 0x1fda;
break;
case 0x1f77:
k = 0x1fdb;
break;
case 0x1fe0:
k = 0x1fe8;
break;
case 0x1fe1:
k = 0x1fe9;
break;
case 0x1f7a:
k = 0x1fea;
break;
case 0x1f7b:
k = 0x1feb;
break;
case 0x1fe5:
k = 0x1fec;
break;
case 0x1f78:
k = 0x1ff8;
break;
case 0x1f79:
k = 0x1ff9;
break;
case 0x1f7c:
k = 0x1ffa;
break;
case 0x1f7d:
k = 0x1ffb;
break;
case 0x1ff3:
k = 0x1ffc;
break;
default:
k = 0;
}
if (k != 0)
return k;
}
}
else if (c < 0x3000)
{
if (c == 0x214e)
return 0x2132;
if (c == 0x2184)
return 0x2183;
if (c >= 0x2170 && c <= 0x217f)
return (c - 0x10);
if (c >= 0x24d0 && c <= 0x24e9)
return (c - 0x1a);
if (c >= 0x2c30 && c <= 0x2c5e)
return (c - 0x30);
if ((c >= 0x2c68 && c <= 0x2c6c && !(c & 1)) ||
(c >= 0x2c81 && c <= 0x2ce3 && (c & 1)) ||
c == 0x2c73 || c == 0x2c76 ||
c == 0x2cec || c == 0x2cee)
return (c - 1);
if (c >= 0x2c81 && c <= 0x2ce3 && (c & 1))
return (c - 1);
if (c >= 0x2d00 && c <= 0x2d25)
return (c - 0x1c60);
switch (c)
{
case 0x2c61:
return 0x2c60;
case 0x2c65:
return 0x023a;
case 0x2c66:
return 0x023e;
}
}
else if (c >= 0xa000 && c < 0xb000)
{
if (((c >= 0xa641 && c <= 0xa65f) ||
(c >= 0xa663 && c <= 0xa66d) ||
(c >= 0xa681 && c <= 0xa697) ||
(c >= 0xa723 && c <= 0xa72f) ||
(c >= 0xa733 && c <= 0xa76f) ||
(c >= 0xa77f && c <= 0xa787)) &&
(c & 1))
return (c - 1);
if (c == 0xa77a || c == 0xa77c || c == 0xa78c)
return (c - 1);
}
else
{
if (c >= 0xff41 && c <= 0xff5a)
return (c - 0x20);
if (c >= 0x10428 && c <= 0x1044f)
return (c - 0x28);
}
return c;
#else
return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);
#endif /* _MB_CAPABLE */
}

355
programs/develop/libraries/newlib/ctype/utf8alpha.h Normal file
View File

@ -0,0 +1,355 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/* Generated using UnicodeData.txt 5.2 */
/* Expression used to filter out the characters for the below tables:
awk -F\; \
'{ \
VAL = strtonum (sprintf("0x%s", $1)); \
# All of general category "L", except for two Thai characters which \
# are actually punctuation characters. Old Unicode weirdness. \
# The character "COMBINING GREEK YPOGEGRAMMENI", as well as all Thai \
# characters which are in "Mn" category. Old Unicode weirdness. \
# All numerical digit or letter characters, except the ASCII variants. \
# This is necessary due to the unfortunate ISO C definition for the \
# iswdigit class, otherwise these characters are missing in iswalnum. \
# All "Other Symbols" which are named as "LETTER" characters. \
# \
# Before running this test, make sure to expand all Unicode blocks \
# which are just marked by their first and last character! \
# \
if ( (match($3, "^L") && VAL != 0x0e2f && VAL != 0x0e46) \
|| (match($3, "^Mn") && (VAL == 0x0345 || match($2, "\\<CHARACTER\\>"))) \
|| (match($3, "^N[dl]") && VAL >= 0x100) \
|| (match($3, "^So") && match($2, "\\<LETTER\\>"))) \
print $1; \
}' UnicodeData.txt
*/
static const unsigned char u0[] = {
0x41, 0x0, 0x5a, 0x61, 0x0, 0x7a, 0xaa, 0xb5,
0xba, 0xc0, 0x0, 0xd6, 0xd8, 0x0, 0xf6, 0xf8,
0x0, 0xff };
/* u1 all alphabetic */
static const unsigned char u2[] = {
0x00, 0x0, 0xc1, 0xc6, 0x0, 0xd1,
0xe0, 0x0, 0xe4, 0xec, 0xee };
static const unsigned char u3[] = {
0x45, 0x70, 0x0, 0x74, 0x76, 0x77,
0x7a, 0x0, 0x7d, 0x86, 0x88, 0x0, 0x8a, 0x8c,
0x8e, 0x0, 0xa1, 0xa3, 0x0, 0xf5,
0xf7, 0x0, 0xff };
static const unsigned char u4[] = {
0x00, 0x0, 0x81, 0x8a, 0x0, 0xff };
static const unsigned char u5[] = {
0x00, 0x0, 0x25, 0x31, 0x0, 0x56, 0x59,
0x61, 0x0, 0x87, 0xd0, 0x0, 0xea,
0xf0, 0x0, 0xf2 };
static const unsigned char u6[] = {
0x21, 0x0, 0x4a, 0x60, 0x0, 0x69,
0x6e, 0x0, 0x6f, 0x71, 0x0, 0xd3,
0xd5, 0xe5, 0x0, 0xe6, 0xee, 0x0, 0xfc, 0xff };
static const unsigned char u7[] = {
0x10, 0x12, 0x0, 0x2f, 0x4d, 0x0, 0xa5, 0xb1,
0xc0, 0x0, 0xea, 0xf4, 0xf5, 0xfa };
static const unsigned char u8[] = {
0x00, 0x0, 0x15, 0x1a, 0x24, 0x28 };
static const unsigned char u9[] = {
0x04, 0x0, 0x39, 0x3d, 0x50, 0x58, 0x0, 0x61,
0x66, 0x0, 0x6f, 0x71, 0x72, 0x79, 0x0, 0x7f,
0x85, 0x0, 0x8c, 0x8f, 0x0, 0x90,
0x93, 0x0, 0xa8, 0xaa, 0x0, 0xb0, 0xb2,
0xb6, 0x0, 0xb9, 0xbd, 0xce, 0xdc, 0x0, 0xdd,
0xdf, 0x0, 0xe1, 0xe6, 0x0, 0xf1 };
static const unsigned char ua[] = {
0x05, 0x0, 0x0a, 0x0f, 0x0, 0x10,
0x13, 0x0, 0x28, 0x2a, 0x0, 0x30,
0x32, 0x0, 0x33, 0x35, 0x0, 0x36,
0x38, 0x0, 0x39, 0x59, 0x0, 0x5c,
0x5e, 0x66, 0x0, 0x6f, 0x72, 0x0, 0x74,
0x85, 0x0, 0x8d, 0x8f, 0x0, 0x91,
0x93, 0x0, 0xa8, 0xaa, 0x0, 0xb0,
0xb2, 0x0, 0xb3, 0xb5, 0x0, 0xb9,
0xbd, 0xd0, 0xe0, 0xe1, 0xe6, 0x0, 0xef };
static const unsigned char ub[] = {
0x05, 0x0, 0x0c, 0x0f, 0x0, 0x10,
0x13, 0x0, 0x28, 0x2a, 0x0, 0x30,
0x32, 0x0, 0x33, 0x35, 0x0, 0x39, 0x3d,
0x5c, 0x0, 0x5d, 0x5f, 0x0, 0x61,
0x66, 0x0, 0x6f, 0x71, 0x83, 0x85, 0x0, 0x8a,
0x8e, 0x0, 0x90, 0x92, 0x0, 0x95,
0x99, 0x0, 0x9a, 0x9c, 0x9e, 0x0, 0x9f,
0xa3, 0x0, 0xa4, 0xa8, 0x0, 0xaa,
0xae, 0x0, 0xb9, 0xd0, 0xe6, 0x0, 0xef };
static const unsigned char uc[] = {
0x05, 0x0, 0x0c, 0x0e, 0x0, 0x10,
0x12, 0x0, 0x28, 0x2a, 0x0, 0x33,
0x35, 0x0, 0x39, 0x3d, 0x58, 0x59,
0x60, 0x0, 0x61, 0x66, 0x0, 0x6f,
0x85, 0x0, 0x8c, 0x8e, 0x0, 0x90,
0x92, 0x0, 0xa8, 0xaa, 0x0, 0xb3,
0xb5, 0x0, 0xb9, 0xbd, 0xde, 0xe0, 0x0, 0xe1,
0xe6, 0x0, 0xef };
static const unsigned char ud[] = {
0x05, 0x0, 0x0c, 0x0e, 0x0, 0x10,
0x12, 0x0, 0x28, 0x2a, 0x0, 0x39, 0x3d,
0x60, 0x0, 0x61, 0x66, 0x0, 0x6f,
0x7a, 0x0, 0x7f, 0x85, 0x0, 0x96, 0x9a,
0x0, 0xb1, 0xb3, 0x0, 0xbb, 0xbd,
0xc0, 0x0, 0xc6 };
static const unsigned char ue[] = {
0x01, 0x0, 0x2e, 0x30, 0x0, 0x3a, 0x40,
0x0, 0x45, 0x47, 0x0, 0x4e, 0x50, 0x0, 0x59,
0x81, 0x0, 0x82, 0x84, 0x87, 0x0, 0x88, 0x8a,
0x8d, 0x94, 0x0, 0x97, 0x99, 0x0, 0x9f, 0xa1,
0x0, 0xa3, 0xa5, 0xa7, 0xaa, 0x0, 0xab, 0xad,
0x0, 0xb0, 0xb2, 0x0, 0xb3, 0xbd, 0xc0, 0x0,
0xc4, 0xc6, 0xd0, 0x0, 0xd9, 0xdc, 0x0, 0xdd };
static const unsigned char uf[] = {
0x00, 0x20, 0x0, 0x29, 0x40, 0x0, 0x47, 0x49,
0x0, 0x6c, 0x88, 0x0, 0x8b };
static const unsigned char u10[] = {
0x00, 0x0, 0x2a, 0x3f, 0x0, 0x49,
0x50, 0x0, 0x55, 0x5a, 0x0, 0x5d,
0x61, 0x65, 0x66, 0x6e, 0x0, 0x70,
0x75, 0x0, 0x81, 0x8e, 0x90, 0x0, 0x99,
0xa0, 0x0, 0xc5, 0xd0, 0x0, 0xfa, 0xfc };
/* u11 all alphabetic */
static const unsigned char u12[] = {
0x00, 0x0, 0x48, 0x4a, 0x0, 0x4d,
0x50, 0x0, 0x56, 0x58, 0x5a, 0x0, 0x5d,
0x60, 0x0, 0x88, 0x8a, 0x0, 0x8d,
0x90, 0x0, 0xb0, 0xb2, 0x0, 0xb5,
0xb8, 0x0, 0xbe, 0xc0, 0xc2, 0x0, 0xc5,
0xc8, 0x0, 0xd6, 0xd8, 0x0, 0xff };
static const unsigned char u13[] = {
0x00, 0x0, 0x10, 0x12, 0x0, 0x15,
0x18, 0x0, 0x5a, 0x80, 0x0, 0x8f,
0xa0, 0x0, 0xf4 };
static const unsigned char u14[] = {
0x01, 0x0, 0xff };
/* u15 all alphabetic */
static const unsigned char u16[] = {
0x00, 0x0, 0x6c, 0x6f, 0x0, 0x7f,
0x81, 0x0, 0x9a, 0xa0, 0x0, 0xea,
0xee, 0x0, 0xf0 };
static const unsigned char u17[] = {
0x00, 0x0, 0x0c, 0x0e, 0x0, 0x11,
0x20, 0x0, 0x31, 0x40, 0x0, 0x51,
0x60, 0x0, 0x6c, 0x6e, 0x0, 0x70,
0x80, 0x0, 0xb3, 0xd7, 0xdc, 0xe0, 0x0, 0xe9 };
static const unsigned char u18[] = {
0x10, 0x0, 0x19, 0x20, 0x0, 0x77,
0x80, 0x0, 0xa8, 0xaa, 0xb0, 0x0, 0xf5 };
static const unsigned char u19[] = {
0x00, 0x0, 0x1c, 0x46, 0x0, 0x6d,
0x70, 0x0, 0x74, 0x80, 0x0, 0xab,
0xc1, 0x0, 0xc7, 0xd0, 0x0, 0xda };
static const unsigned char u1a[] = {
0x00, 0x0, 0x16, 0x20, 0x0, 0x54,
0x80, 0x0, 0x89, 0x90, 0x0, 0x99, 0xa7 };
static const unsigned char u1b[] = {
0x05, 0x0, 0x33, 0x45, 0x0, 0x4b,
0x50, 0x0, 0x59, 0x83, 0x0, 0xa0,
0xae, 0x0, 0xb9 };
static const unsigned char u1c[] = {
0x00, 0x0, 0x23, 0x40, 0x0, 0x49,
0x4d, 0x0, 0x7d, 0xe9, 0x0, 0xec,
0xee, 0x0, 0xf1 };
static const unsigned char u1d[] = {
0x00, 0x0, 0xbf };
/* u1e all alphabetic */
static const unsigned char u1f[] = {
0x00, 0x0, 0x15, 0x18, 0x0, 0x1d,
0x20, 0x0, 0x45, 0x48, 0x0, 0x4d, 0x50, 0x0, 0x57, 0x59,
0x5b, 0x5d, 0x5f, 0x0, 0x7d, 0x80, 0x0, 0xb4,
0xb6, 0x0, 0xbc, 0xbe, 0xc2, 0x0, 0xc4, 0xc6,
0x0, 0xcc, 0xd0, 0x0, 0xd3, 0xd6, 0x0, 0xdb,
0xe0, 0x0, 0xec, 0xf2, 0x0, 0xf4, 0xf6, 0x0,
0xfc };
static const unsigned char u20[] = {
0x71, 0x7f, 0x90, 0x0, 0x94 };
static const unsigned char u21[] = {
0x02, 0x07, 0x0a, 0x0, 0x13, 0x15,
0x19, 0x0, 0x1d, 0x24, 0x26, 0x28, 0x0, 0x2d,
0x2f, 0x0, 0x39, 0x3c, 0x0, 0x3f,
0x45, 0x0, 0x49, 0x4e, 0x60, 0x0, 0x88 };
static const unsigned char u24[] = {
0x9c, 0x0, 0xe9 };
static const unsigned char u2c[] = {
0x00, 0x0, 0x2e, 0x30, 0x0, 0x5e,
0x60, 0x0, 0xe4, 0xeb, 0x0, 0xee };
static const unsigned char u2d[] = {
0x00, 0x0, 0x25, 0x30, 0x0, 0x65, 0x6f,
0x80, 0x0, 0x96, 0xa0, 0x0, 0xa6,
0xa8, 0x0, 0xae, 0xb0, 0x0, 0xb6,
0xb8, 0x0, 0xbe, 0xc0, 0x0, 0xc6,
0xc8, 0x0, 0xce, 0xd0, 0x0, 0xd6,
0xd8, 0x0, 0xde };
static const unsigned char u2e[] = {
0x2f };
static const unsigned char u30[] = {
0x05, 0x0, 0x07, 0x21, 0x0,
0x29, 0x31, 0x0, 0x35, 0x38, 0x0, 0x3c, 0x41,
0x0, 0x96, 0x9d, 0x0, 0x9f, 0xa1, 0x0, 0xfa,
0xfc, 0x0, 0xff };
static const unsigned char u31[] = {
0x05, 0x0, 0x2d, 0x31, 0x0,
0x8e, 0xa0, 0x0, 0xb7, 0xf0, 0x0, 0xff };
/* u34 to u4c all alphabetic */
static const unsigned char u4d[] = {
0x00, 0x0, 0xb5 };
/* u4e to u9e all alphabetic */
static const unsigned char u9f[] = {
0x00, 0x0, 0xcb };
/* ua0 to ua3 all alphabetic */
static const unsigned char ua4[] = {
0x00, 0x0, 0x8c, 0xd0, 0x0, 0xfd };
/* ua5 all alphabetic */
static const unsigned char ua6[] = {
0x00, 0x0, 0x0c, 0x10, 0x0, 0x2b,
0x40, 0x0, 0x5f, 0x62, 0x0, 0x6e,
0x7f, 0x0, 0x97, 0xa0, 0x0, 0xef };
static const unsigned char ua7[] = {
0x17, 0x0, 0x1f, 0x22, 0x0, 0x88,
0x8b, 0x8c,
0xfb, 0x0, 0xff };
static const unsigned char ua8[] = {
0x00, 0x01, 0x03, 0x0, 0x05, 0x07, 0x0, 0x0a,
0x0c, 0x0, 0x22, 0x40, 0x0, 0x73,
0x82, 0x0, 0xb3, 0xd0, 0x0, 0xd9,
0xf2, 0x0, 0xf7, 0xfb };
static const unsigned char ua9[] = {
0x00, 0x0, 0x25, 0x30, 0x0, 0x46,
0x60, 0x0, 0x7c, 0x84, 0x0, 0xb2,
0xcf, 0x0, 0xd9 };
static const unsigned char uaa[] = {
0x00, 0x0, 0x28, 0x40, 0x0, 0x42,
0x44, 0x0, 0x4b, 0x50, 0x0, 0x59,
0x60, 0x0, 0x76, 0x7a, 0x80, 0x0, 0xaf,
0xb1, 0xb5, 0xb6, 0xb9, 0x0, 0xbd,
0xc0, 0xc2, 0xdb, 0x0, 0xdd };
static const unsigned char uab[] = {
0xc0, 0x0, 0xe2, 0xf0, 0x0, 0xf9 };
/* uac to ud6 all alphabetic */
static const unsigned char ud7[] = {
0x00, 0x0, 0xa3, 0xb0, 0x0, 0xc6,
0xcb, 0x0, 0xfb };
/* uf9 all alphabetic */
static const unsigned char ufa[] = {
0x00, 0x0, 0x2d, 0x30, 0x0, 0x6d,
0x70, 0x0, 0xd9 };
static const unsigned char ufb[] = {
0x00, 0x0, 0x06, 0x13, 0x0, 0x17, 0x1d,
0x1f, 0x0, 0x28, 0x2a, 0x0, 0x36, 0x38, 0x0,
0x3c, 0x3e, 0x40, 0x0, 0x41, 0x43, 0x0, 0x44,
0x46, 0x0, 0xb1, 0xd3, 0x0, 0xff };
/* ufc all alphabetic */
static const unsigned char ufd[] = {
0x00, 0x0, 0x3d, 0x50, 0x0,
0x8f, 0x92, 0x0, 0xc7, 0xf0, 0x0, 0xfb };
static const unsigned char ufe[] = {
0x70,
0x0, 0x74, 0x76, 0x0, 0xfc };
static const unsigned char uff[] = {
0x10, 0x0, 0x19,
0x21, 0x0, 0x3a, 0x41, 0x0, 0x5a, 0x66, 0x0,
0xbe, 0xc2, 0x0, 0xc7, 0xca, 0x0, 0xcf, 0xd2,
0x0, 0xd7, 0xda, 0x0, 0xdc };
static const unsigned char u100[] = {
0x00, 0x0, 0x0b, 0x0d, 0x0, 0x26,
0x28, 0x0, 0x3a, 0x3c, 0x3d, 0x3f, 0x0, 0x4d,
0x50, 0x0, 0x5d, 0x80, 0x0, 0xfa };
static const unsigned char u101[] = {
0x40, 0x0, 0x74 };
static const unsigned char u102[] = {
0x80, 0x0, 0x9c, 0xa0, 0x0, 0xd0 };
static const unsigned char u103[] = {
0x00, 0x0, 0x1e, 0x30, 0x0, 0x4a,
0x80, 0x0, 0x9d, 0xa0, 0x0, 0xc3,
0xc8, 0x0, 0xcf, 0xd1, 0x0, 0xd5 };
static const unsigned char u104[] = {
0x00, 0x0, 0x9d, 0xa0, 0x0, 0xa9 };
static const unsigned char u108[] = {
0x00, 0x0, 0x05, 0x08, 0x0a, 0x0, 0x35,
0x37, 0x38, 0x3c, 0x3f, 0x0, 0x55 };
static const unsigned char u109[] = {
0x00, 0x0, 0x15, 0x20, 0x0, 0x39 };
static const unsigned char u10a[] = {
0x00, 0x10, 0x0, 0x13, 0x15, 0x0, 0x17,
0x19, 0x0, 0x33, 0x60, 0x0, 0x7c };
static const unsigned char u10b[] = {
0x00, 0x0, 0x35, 0x40, 0x0, 0x55,
0x60, 0x0, 0x72 };
static const unsigned char u10c[] = {
0x00, 0x0, 0x48 };
static const unsigned char u110[] = {
0x83, 0x0, 0xaf };
/* u120 to u122 all alphabetic */
static const unsigned char u123[] = {
0x00, 0x0, 0x6e };
static const unsigned char u124[] = {
0x00, 0x0, 0x62 };
/* u130 to u133 all alphabetic */
static const unsigned char u134[] = {
0x00, 0x0, 0x2e };
static const unsigned char u1d4[] = {
0x00, 0x0, 0x54, 0x56, 0x0, 0x9c,
0x9e, 0x0, 0x9f, 0xa2, 0xa5, 0x0, 0xa6,
0xa9, 0x0, 0xac, 0xae, 0x0, 0xb9, 0xbb,
0xbd, 0x0, 0xc3, 0xc5, 0x0, 0xff };
static const unsigned char u1d5[] = {
0x00, 0x0, 0x05, 0x07, 0x0,
0x0a, 0x0d, 0x0, 0x14, 0x16, 0x0, 0x1c, 0x1e,
0x0, 0x39, 0x3b, 0x0, 0x3e, 0x40, 0x0, 0x44,
0x46, 0x4a, 0x0, 0x50, 0x52, 0x0, 0xff };
static const unsigned char u1d6[] = {
0x00, 0x0, 0xa5, 0xa8, 0x0, 0xc0,
0xc2, 0x0, 0xda, 0xdc, 0x0, 0xfa,
0xfc, 0x0, 0xff };
static const unsigned char u1d7[] = {
0x00, 0x0, 0x14, 0x16, 0x0, 0x34,
0x36, 0x0, 0x4e, 0x50, 0x0, 0x6e,
0x70, 0x0, 0x88, 0x8a, 0x0, 0xa8,
0xaa, 0x0, 0xc2, 0xc4, 0x0, 0xcb,
0xce, 0x0, 0xff };
static const unsigned char u1f1[] = {
0x10, 0x0, 0x2c, 0x31, 0x3d, 0x3f, 0x42, 0x46,
0x57, 0x5f, 0x79, 0x7b, 0x7c, 0x7f, 0x8a };
/* u200 to u2a5 all alphabetic */
static const unsigned char u2a6[] = {
0x00, 0x0, 0xd6 };
/* u2a7 to u2b6 all alphabetic */
static const unsigned char u2b7[] = {
0x00, 0x0, 0x34 };
/* u2f8 to u2f9 all alphabetic */
static const unsigned char u2fa[] = {
0x00, 0x0, 0x1d };

389
programs/develop/libraries/newlib/ctype/utf8print.h Normal file
View File

@ -0,0 +1,389 @@
/* Copyright (c) 2002 Red Hat Incorporated.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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.
The name of Red Hat Incorporated may not be used to endorse
or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 RED HAT INCORPORATED 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.
*/
/* Generated using UnicodeData.txt 5.2 */
/* Expression used to filter out the characters for the below tables:
awk -F\; \
'{ \
VAL = strtonum (sprintf("0x%s", $1)); \
# All valid characters except from categories Cc (C0 or C1 control code), \
# Cs (Surrogates), Zl (Line separator), and Zp (Paragraph separator).\
# \
# Before running this test, make sure to expand all Unicode blocks \
# which are just marked by their first and last character! \
# \
if (!match($3, "^C[cs]") && !match($3, "^Z[lp]")) \
print $1; \
}' UnicodeData.txt
*/
static const unsigned char u0[] = {
0x20, 0x0, 0x7e, 0xa0, 0x0, 0xff };
/* u1 is all-print */
/* u2 is all-print */
static const unsigned char u3[] = {
0x00, 0x0, 0x77, 0x7a, 0x0, 0x7e,
0x84, 0x0, 0x8a, 0x8c, 0x8e, 0x0,
0xa1, 0xa3, 0x0, 0xff };
/* u4 is all-print */
static const unsigned char u5[] = {
0x00, 0x0, 0x25, 0x31, 0x0,
0x56, 0x59, 0x0, 0x5f, 0x61, 0x0, 0x87, 0x89,
0x0, 0x8a, 0x91, 0x0, 0xc7, 0xd0, 0x0, 0xea,
0xf0, 0x0, 0xf4 };
static const unsigned char u6[] = {
0x00, 0x0, 0x03, 0x06, 0x0, 0x1b, 0x1e, 0x1f,
0x21, 0x0, 0x5e, 0x60, 0x0, 0xff };
static const unsigned char u7[] = {
0x00, 0x0, 0x0d, 0x0f, 0x0, 0x4a, 0x4d, 0x0, 0xb1,
0xc0, 0x0, 0xfa };
static const unsigned char u8[] = {
0x00, 0x0, 0x2d, 0x30, 0x0, 0x3e, };
static const unsigned char u9[] = {
0x00, 0x0, 0x39, 0x3c, 0x0, 0x4e, 0x50, 0x0, 0x55,
0x58, 0x0, 0x72, 0x79, 0x0, 0x7f, 0x81, 0x0, 0x83,
0x85, 0x0, 0x8c, 0x8f, 0x0, 0x90, 0x93, 0x0, 0xa8,
0xaa, 0x0, 0xb0, 0xb2, 0xb6, 0x0, 0xb9, 0xbc,
0x0, 0xc4, 0xc7, 0xc8, 0xcb, 0x0, 0xce,
0xd7, 0xdc, 0x0, 0xdd, 0xdf, 0x0, 0xe3, 0xe6,
0x0, 0xfb };
static const unsigned char ua[] = {
0x01, 0x0, 0x03, 0x05, 0x0, 0x0a, 0x0f, 0x0,
0x10, 0x13, 0x0, 0x28, 0x2a, 0x0, 0x30, 0x32,
0x0, 0x33, 0x35, 0x0, 0x36, 0x38, 0x0, 0x39,
0x3c, 0x3e, 0x0, 0x42, 0x47, 0x0, 0x48, 0x4b,
0x0, 0x4d, 0x51, 0x59, 0x0, 0x5c, 0x5e, 0x66, 0x0,
0x75, 0x81, 0x0, 0x83, 0x85, 0x0, 0x8d,
0x8f, 0x0, 0x91, 0x93, 0x0, 0xa8, 0xaa, 0x0,
0xb0, 0xb2, 0x0, 0xb3, 0xb5, 0x0, 0xb9, 0xbc,
0x0, 0xc5, 0xc7, 0x0, 0xc9, 0xcb, 0x0, 0xcd,
0xd0, 0xe0, 0x0, 0xe3, 0xe6, 0x0, 0xef, 0xf1 };
static const unsigned char ub[] = {
0x01, 0x0, 0x03,
0x05, 0x0, 0x0c, 0x0f, 0x0, 0x10, 0x13, 0x0,
0x28, 0x2a, 0x0, 0x30, 0x32, 0x0, 0x33, 0x35,
0x0, 0x39, 0x3c, 0x0, 0x44, 0x47, 0x0, 0x48,
0x4b, 0x0, 0x4d, 0x56, 0x0, 0x57, 0x5c, 0x0,
0x5d, 0x5f, 0x0, 0x63, 0x66, 0x0, 0x71, 0x82,
0x0, 0x83, 0x85, 0x0, 0x8a, 0x8e, 0x0, 0x90,
0x92, 0x0, 0x95, 0x99, 0x0, 0x9a, 0x9c, 0x9e,
0x0, 0x9f, 0xa3, 0x0, 0xa4, 0xa8, 0x0, 0xaa,
0xae, 0x0, 0xb9, 0xbe, 0x0,
0xc2, 0xc6, 0x0, 0xc8, 0xca, 0x0, 0xcd, 0xd0,
0xd7, 0xe6, 0xe7, 0x0, 0xfa };
static const unsigned char uc[] = {
0x01, 0x0, 0x03, 0x05, 0x0,
0x0c, 0x0e, 0x0, 0x10, 0x12, 0x0, 0x28, 0x2a,
0x0, 0x33, 0x35, 0x0, 0x39, 0x3d, 0x0, 0x44,
0x46, 0x0, 0x48, 0x4a, 0x0, 0x4d, 0x55, 0x0,
0x56, 0x58, 0x59, 0x60, 0x0, 0x63, 0x66, 0x0, 0x6f,
0x78, 0x0, 0x7f, 0x82, 0x83, 0x85, 0x0, 0x8c,
0x8e, 0x0, 0x90, 0x92, 0x0, 0xa8, 0xaa, 0x0, 0xb3,
0xb5, 0x0, 0xb9, 0xbc, 0x0, 0xc4, 0xc6, 0x0, 0xc8,
0xca, 0x0, 0xcd, 0xd5, 0x0, 0xd6, 0xde, 0xe0, 0x0,
0xe3, 0xe6, 0x0, 0xef, 0xf1, 0xf2 };
static const unsigned char ud[] = {
0x02, 0x0, 0x03, 0x05,
0x0, 0x0c, 0x0e, 0x0, 0x10, 0x12, 0x0, 0x28,
0x2a, 0x0, 0x39, 0x3d, 0x0, 0x44, 0x46, 0x0,
0x48, 0x4a, 0x0, 0x4d, 0x57, 0x60, 0x0, 0x63,
0x66, 0x0, 0x75, 0x79, 0x0, 0x7f, 0x82, 0x0, 0x83,
0x85, 0x0, 0x96, 0x9a, 0x0, 0xb1, 0xb3, 0x0, 0xbb,
0xbd, 0xc0, 0x0, 0xc6, 0xca, 0xcf, 0x0, 0xd4, 0xd6,
0xd8, 0x0, 0xdf, 0xf2, 0x0, 0xf4 };
static const unsigned char ue[] = {
0x01, 0x0,
0x3a, 0x3f, 0x0, 0x5b, 0x81, 0x0, 0x82, 0x84,
0x87, 0x0, 0x88, 0x8a, 0x8d, 0x94, 0x0, 0x97,
0x99, 0x0, 0x9f, 0xa1, 0x0, 0xa3, 0xa5, 0xa7,
0xaa, 0x0, 0xab, 0xad, 0x0, 0xb9, 0xbb, 0x0,
0xbd, 0xc0, 0x0, 0xc4, 0xc6, 0xc8, 0x0, 0xcd,
0xd0, 0x0, 0xd9, 0xdc, 0x0, 0xdd };
static const unsigned char uf[] = {
0x00, 0x0, 0x47, 0x49, 0x0, 0x6c,
0x71, 0x0, 0x8b, 0x90, 0x0, 0x97,
0x99, 0x0, 0xbc, 0xbe, 0x0, 0xcc,
0xce, 0x0, 0xd8 };
static const unsigned char u10[] = {
0x00, 0x0, 0xc5, 0xd0, 0x0, 0xfc };
/* u11 is all-print */
static const unsigned char u12[] = {
0x00, 0x0, 0x48, 0x4a, 0x0, 0x4d, 0x50, 0x0, 0x56,
0x58, 0x5a, 0x0, 0x5d, 0x60, 0x0, 0x88,
0x8a, 0x0, 0x8d, 0x90, 0x0, 0xb0, 0xb2,
0x0, 0xb5, 0xb8, 0x0, 0xbe, 0xc0, 0xc2, 0x0,
0xc5, 0xc8, 0x0, 0xd6, 0xd8, 0x0, 0xff };
static const unsigned char u13[] = {
0x00, 0x0, 0x10, 0x12, 0x0, 0x15,
0x18, 0x0, 0x5a, 0x5f, 0x0, 0x7c,
0x80, 0x0, 0x99, 0xa0, 0x0, 0xf4 };
/* u14 is all-print */
/* u15 is all-print */
static const unsigned char u16[] = {
0x00, 0x0, 0x9c, 0xa0, 0x0, 0xf0 };
static const unsigned char u17[] = {
0x00, 0x0, 0x0c, 0x0e, 0x0, 0x14, 0x20,
0x0, 0x36, 0x40, 0x0, 0x53, 0x60, 0x0, 0x6c,
0x6e, 0x0, 0x70, 0x72, 0x0, 0x73, 0x80, 0x0,
0xdd, 0xe0, 0x0, 0xe9, 0xf0, 0x0, 0xf9 };
static const unsigned char u18[] = {
0x00, 0x0, 0x0e, 0x10,
0x0, 0x19, 0x20, 0x0, 0x77, 0x80, 0x0, 0xaa,
0xb0, 0x0, 0xf5 };
static const unsigned char u19[] = {
0x00, 0x0, 0x1c, 0x20, 0x0, 0x2b,
0x30, 0x0, 0x3b, 0x40, 0x44, 0x0, 0x6d,
0x70, 0x0, 0x74, 0x80, 0x0, 0xab,
0xb0, 0x0, 0xc9, 0xd0, 0x0, 0xda,
0xde, 0x0, 0xff };
static const unsigned char u1a[] = {
0x00, 0x0, 0x1b, 0x1e, 0x0, 0x5e,
0x60, 0x0, 0x7c, 0x7f, 0x0, 0x89,
0x90, 0x0, 0x99, 0xa0, 0x0, 0xad };
static const unsigned char u1b[] = {
0x00, 0x0, 0x4b, 0x50, 0x0, 0x7c,
0x80, 0x0, 0xaa, 0xae, 0x0, 0xb9 };
static const unsigned char u1c[] = {
0x00, 0x0, 0x37, 0x3b, 0x0, 0x49,
0x4d, 0x0, 0x7f, 0xd0, 0x0, 0xf2 };
static const unsigned char u1d[] = {
0x00, 0x0, 0xe6, 0xfd, 0x0, 0xff };
/* u1e is all-print */
static const unsigned char u1f[] = {
0x00, 0x0,
0x15, 0x18, 0x0, 0x1d, 0x20, 0x0, 0x45, 0x48,
0x0, 0x4d, 0x50, 0x0, 0x57, 0x59, 0x5b, 0x5d,
0x5f, 0x0, 0x7d, 0x80, 0x0, 0xb4, 0xb6, 0x0,
0xc4, 0xc6, 0x0, 0xd3, 0xd6, 0x0, 0xdb, 0xdd,
0x0, 0xef, 0xf2, 0x0, 0xf4, 0xf6, 0x0, 0xfe };
static const unsigned char u20[] = {
0x00, 0x0, 0x27, 0x2a, 0x0, 0x64,
0x6a, 0x0, 0x71, 0x74, 0x0, 0x8e,
0x90, 0x0, 0x94, 0xa0, 0x0, 0xb8,
0xd0, 0x0, 0xf0 };
static const unsigned char u21[] = {
0x00, 0x0, 0x89, 0x90, 0x0, 0xff };
/* u22 is all-print */
static const unsigned char u23[] = {
0x00, 0x0, 0xe8 };
static const unsigned char u24[] = {
0x00, 0x0, 0x26, 0x40, 0x0, 0x4a,
0x60, 0x0, 0xff };
/* u25 is all-print */
static const unsigned char u26[] = {
0x00, 0x0, 0xcd, 0xcf, 0x0, 0xe1,
0xe3, 0xe8, 0x0, 0xff };
static const unsigned char u27[] = {
0x01, 0x0, 0x04, 0x06, 0x0, 0x09,
0x0c, 0x0, 0x27, 0x29, 0x0, 0x4b, 0x4d,
0x4f, 0x0, 0x52, 0x56, 0x0, 0x5e,
0x61, 0x0, 0x94, 0x98, 0x0, 0xaf,
0xb1, 0x0, 0xbe, 0xc0, 0x0, 0xca, 0xcc,
0xd0, 0x0, 0xff };
/* u28 to u2a are all-print */
static const unsigned char u2b[] = {
0x00, 0x0, 0x4c, 0x50, 0x0, 0x59 };
static const unsigned char u2c[] = {
0x00, 0x0, 0x2e, 0x30, 0x0, 0x5e,
0x60, 0x0, 0xf1, 0xf9, 0x0, 0xff };
static const unsigned char u2d[] = {
0x00, 0x0, 0x25, 0x30, 0x0, 0x65, 0x6f,
0x80, 0x0, 0x96, 0xa0, 0x0, 0xa6,
0xa8, 0x0, 0xae, 0xb0, 0x0, 0xb6,
0xb8, 0x0, 0xbe, 0xc0, 0x0, 0xc6,
0xc8, 0x0, 0xce, 0xd0, 0x0, 0xd6,
0xd8, 0x0, 0xde, 0xe0, 0x0, 0xff };
static const unsigned char u2e[] = {
0x00, 0x0, 0x31, 0x80, 0x0, 0x99,
0x9b, 0x0, 0xf3 };
static const unsigned char u2f[] = {
0x00, 0x0, 0xd5, 0xf0, 0x0, 0xfb };
static const unsigned char u30[] = {
0x00, 0x0,
0x3f, 0x41, 0x0, 0x96, 0x99, 0x0, 0xff };
static const unsigned char u31[] = {
0x05, 0x0, 0x2d, 0x31, 0x0, 0x8e,
0x90, 0x0, 0xb7, 0xc0, 0x0, 0xe3,
0xf0, 0x0, 0xff };
static const unsigned char u32[] = {
0x00, 0x0, 0x1e, 0x20, 0x0, 0xfe };
/* u33 to u4c is all-print */
static const unsigned char u4d[] = {
0x00, 0x0, 0xb5, 0xc0, 0x0, 0xff };
/* u4e to u9e is all-print */
static const unsigned char u9f[] = {
0x00, 0x0, 0xcb };
/* ua0 to ua3 is all-print */
static const unsigned char ua4[] = {
0x00, 0x0, 0x8c, 0x90, 0x0, 0xc6,
0xd0, 0x0, 0xff };
/* ua5 is all-print */
static const unsigned char ua6[] = {
0x00, 0x0, 0x2b, 0x40, 0x0, 0x5f,
0x62, 0x0, 0x73, 0x7c, 0x0, 0x97,
0xa0, 0x0, 0xf7 };
static const unsigned char ua7[] = {
0x00, 0x0, 0x8c, 0xfb, 0x0, 0xff };
static const unsigned char ua8[] = {
0x00, 0x0, 0x2b, 0x30, 0x0, 0x39,
0x40, 0x0, 0x77, 0x80, 0x0, 0xc4,
0xce, 0x0, 0xd9, 0xe0, 0x0, 0xfb };
static const unsigned char ua9[] = {
0x00, 0x0, 0x53, 0x5f, 0x0, 0x7c,
0x80, 0x0, 0xcd, 0xcf, 0x0, 0xd9,
0xde, 0xdf };
static const unsigned char uaa[] = {
0x00, 0x0, 0x36, 0x40, 0x0, 0x4d,
0x50, 0x0, 0x59, 0x5c, 0x0, 0x7b,
0x80, 0x0, 0xc2, 0xdb, 0x0, 0xdf };
static const unsigned char uab[] = {
0xc0, 0x0, 0xed, 0xf0, 0x0, 0xf9 };
/* uac to ud6 is all-print */
static const unsigned char ud7[] = {
0x00, 0x0, 0xa3, 0xb0, 0x0, 0xc6,
0xcb, 0x0, 0xfb };
/* ud8 to udf are UTF-16 surrogates, non-printable */
/* ue0 to uf9 is all-print */
static const unsigned char ufa[] = {
0x00, 0x0, 0x2d, 0x30, 0x0, 0x6d,
0x70, 0x0, 0xd9 };
static const unsigned char ufb[] = {
0x00, 0x0, 0x06, 0x13, 0x0, 0x17,
0x1d, 0x0, 0x36, 0x38, 0x0, 0x3c,
0x3e, 0x40, 0x41, 0x43, 0x44,
0x46, 0x0, 0xb1, 0xd3, 0x0, 0xff };
/* ufc is all-print */
static const unsigned char ufd[] = {
0x00, 0x0, 0x3f, 0x50, 0x0, 0x8f,
0x92, 0x0, 0xc7, 0xf0, 0x0, 0xfd };
static const unsigned char ufe[] = {
0x00, 0x0, 0x19, 0x20, 0x0, 0x26,
0x30, 0x0, 0x52, 0x54, 0x0, 0x66,
0x68, 0x0, 0x6b, 0x70, 0x0, 0x74,
0x76, 0x0, 0xfc, 0xff };
static const unsigned char uff[] = {
0x01, 0x0, 0xbe, 0xc2, 0x0, 0xc7, 0xca, 0x0,
0xcf, 0xd2, 0x0, 0xd7, 0xda, 0x0, 0xdc, 0xe0,
0x0, 0xe6, 0xe8, 0x0, 0xee, 0xf9, 0x0, 0xfd };
static const unsigned char u100[] = {
0x00, 0x0, 0x0b, 0x0d, 0x0, 0x26,
0x28, 0x0, 0x3a, 0x3c, 0x3d, 0x3f, 0x0, 0x4d,
0x50, 0x0, 0x5d, 0x80, 0x0, 0xfa };
static const unsigned char u101[] = {
0x00, 0x0, 0x02, 0x07, 0x0, 0x33,
0x37, 0x0, 0x8a, 0x90, 0x0, 0x9b,
0xd0, 0x0, 0xfd };
static const unsigned char u102[] = {
0x80, 0x0, 0x9c, 0xa0, 0x0, 0xd0 };
static const unsigned char u103[] = {
0x00, 0x0, 0x1e, 0x20, 0x0, 0x23,
0x30, 0x0, 0x4a, 0x80, 0x0, 0x9d,
0x9f, 0x0, 0xc3, 0xc8, 0x0, 0xd5 };
static const unsigned char u104[] = {
0x00, 0x0, 0x9d, 0xa0, 0x0, 0xa9 };
static const unsigned char u108[] = {
0x00, 0x0, 0x05, 0x08, 0x0a, 0x0, 0x35,
0x37, 0x38, 0x3c, 0x3f, 0x0, 0x55,
0x57, 0x0, 0x5f };
static const unsigned char u109[] = {
0x00, 0x0, 0x1b, 0x1f, 0x0, 0x39, 0x3f };
static const unsigned char u10a[] = {
0x00, 0x0, 0x03, 0x05, 0x06, 0x0c, 0x0, 0x13,
0x15, 0x0, 0x17, 0x19, 0x0, 0x33,
0x38, 0x0, 0x3a, 0x3f, 0x0, 0x47,
0x50, 0x0, 0x58, 0x60, 0x0, 0x7f };
static const unsigned char u10b[] = {
0x00, 0x0, 0x35, 0x39, 0x0, 0x55,
0x58, 0x0, 0x72, 0x78, 0x0, 0x7f };
static const unsigned char u10c[] = {
0x00, 0x0, 0x48 };
static const unsigned char u10e[] = {
0x60, 0x0, 0x7e };
static const unsigned char u110[] = {
0x80, 0x0, 0xc1 };
/* u120 to u122 is all-print */
static const unsigned char u123[] = {
0x00, 0x0, 0x6e };
static const unsigned char u124[] = {
0x00, 0x0, 0x62, 0x70, 0x0, 0x73 };
/* u130 to u133 is all-print */
static const unsigned char u134[] = {
0x00, 0x0, 0x2e };
static const unsigned char u1d0[] = {
0x00, 0x0, 0xf5 };
static const unsigned char u1d1[] = {
0x00, 0x0, 0x26, 0x29, 0x0, 0xdd };
static const unsigned char u1d2[] = {
0x00, 0x0, 0x45 };
static const unsigned char u1d3[] = {
0x00, 0x0, 0x56, 0x60, 0x0, 0x71 };
static const unsigned char u1d4[] = {
0x00, 0x0, 0x54, 0x56, 0x0, 0x9c, 0x9e, 0x0,
0x9f, 0xa2, 0xa5, 0x0, 0xa6, 0xa9, 0x0, 0xac,
0xae, 0x0, 0xb9, 0xbb, 0xbd, 0x0, 0xc3,
0xc5, 0x0, 0xff };
static const unsigned char u1d5[] = {
0x00, 0x0, 0x05, 0x07, 0x0, 0x0a,
0x0d, 0x0, 0x14, 0x16, 0x0, 0x1c, 0x1e, 0x0,
0x39, 0x3b, 0x0, 0x3e, 0x40, 0x0, 0x44, 0x46,
0x4a, 0x0, 0x50, 0x52, 0x0, 0xff };
static const unsigned char u1d6[] = {
0x00, 0x0, 0xa5, 0xa8, 0x0, 0xff };
static const unsigned char u1d7[] = {
0x00, 0x0, 0xcb, 0xce, 0x0, 0xff };
static const unsigned char u1f0[] = {
0x00, 0x0, 0x2b, 0x30, 0x0, 0x93 };
static const unsigned char u1f1[] = {
0x00, 0x0, 0x0a, 0x10, 0x0, 0x2e,
0x31, 0x3d, 0x3f, 0x42, 0x46, 0x4a, 0x0, 0x4e,
0x57, 0x5f, 0x79, 0x7b, 0x7c, 0x7f, 0x8a, 0x0,
0x8c, 0x8d, 0x90 };
static const unsigned char u1f2[] = {
0x00, 0x10, 0x0, 0x31, 0x40, 0x0, 0x48 };
/* u200 to u2a5 is all-print */
static const unsigned char u2a6[] = {
0x00, 0x0, 0xd6 };
/* u2a7 to u2b6 is all-print */
static const unsigned char u2b7[] = {
0x00, 0x0, 0x34 };
/* u2f8 to u2f9 is all-print */
static const unsigned char u2fa[] = {
0x00,
0x0, 0x1d };
static const unsigned char ue00[] = {
0x01, 0x20, 0x0, 0x7f };
static const unsigned char ue01[] = {
0x00, 0x0, 0xef };
/* uf00 to uffe is all-print */
static const unsigned char ufff[] = {
0x00, 0x0, 0xfd };
/* u1000 to u10fe is all-print */
static const unsigned char u10ff[] = {
0x00, 0x0, 0xfd };

16
programs/develop/libraries/newlib/errno/errno.c Normal file
View File

@ -0,0 +1,16 @@
/* The errno variable is stored in the reentrancy structure. This
function returns its address for use by the macro errno defined in
errno.h. */
#include <errno.h>
#include <reent.h>
#ifndef _REENT_ONLY
int *
__errno ()
{
return &_REENT->_errno;
}
#endif

133
programs/develop/libraries/newlib/include/_ansi.h Normal file
View File

@ -0,0 +1,133 @@
/* Provide support for both ANSI and non-ANSI environments. */
/* Some ANSI environments are "broken" in the sense that __STDC__ cannot be
relied upon to have it's intended meaning. Therefore we must use our own
concoction: _HAVE_STDC. Always use _HAVE_STDC instead of __STDC__ in newlib
sources!
To get a strict ANSI C environment, define macro __STRICT_ANSI__. This will
"comment out" the non-ANSI parts of the ANSI header files (non-ANSI header
files aren't affected). */
#ifndef _ANSIDECL_H_
#define _ANSIDECL_H_
#include <newlib.h>
#include <sys/config.h>
/* First try to figure out whether we really are in an ANSI C environment. */
/* FIXME: This probably needs some work. Perhaps sys/config.h can be
prevailed upon to give us a clue. */
#ifdef __STDC__
#define _HAVE_STDC
#endif
/* ISO C++. */
#ifdef __cplusplus
#if !(defined(_BEGIN_STD_C) && defined(_END_STD_C))
#ifdef _HAVE_STD_CXX
#define _BEGIN_STD_C namespace std { extern "C" {
#define _END_STD_C } }
#else
#define _BEGIN_STD_C extern "C" {
#define _END_STD_C }
#endif
#if defined(__GNUC__) && \
( (__GNUC__ >= 4) || \
( (__GNUC__ >= 3) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 3) ) )
#define _NOTHROW __attribute__ ((nothrow))
#else
#define _NOTHROW throw()
#endif
#endif
#else
#define _BEGIN_STD_C
#define _END_STD_C
#define _NOTHROW
#endif
#ifdef _HAVE_STDC
#define _PTR void *
#define _AND ,
#define _NOARGS void
#define _CONST const
#define _VOLATILE volatile
#define _SIGNED signed
#define _DOTS , ...
#define _VOID void
#ifdef __CYGWIN__
#define _EXFUN_NOTHROW(name, proto) __cdecl name proto _NOTHROW
#define _EXFUN(name, proto) __cdecl name proto
#define _EXPARM(name, proto) (* __cdecl name) proto
#define _EXFNPTR(name, proto) (__cdecl * name) proto
#else
#define _EXFUN_NOTHROW(name, proto) name proto _NOTHROW
#define _EXFUN(name, proto) name proto
#define _EXPARM(name, proto) (* name) proto
#define _EXFNPTR(name, proto) (* name) proto
#endif
#define _DEFUN(name, arglist, args) name(args)
#define _DEFUN_VOID(name) name(_NOARGS)
#define _CAST_VOID (void)
#ifndef _LONG_DOUBLE
#define _LONG_DOUBLE long double
#endif
#ifndef _LONG_LONG_TYPE
#define _LONG_LONG_TYPE long long
#endif
#ifndef _PARAMS
#define _PARAMS(paramlist) paramlist
#endif
#else
#define _PTR char *
#define _AND ;
#define _NOARGS
#define _CONST
#define _VOLATILE
#define _SIGNED
#define _DOTS
#define _VOID void
#define _EXFUN(name, proto) name()
#define _EXFUN_NOTHROW(name, proto) name()
#define _DEFUN(name, arglist, args) name arglist args;
#define _DEFUN_VOID(name) name()
#define _CAST_VOID
#define _LONG_DOUBLE double
#define _LONG_LONG_TYPE long
#ifndef _PARAMS
#define _PARAMS(paramlist) ()
#endif
#endif
/* Support gcc's __attribute__ facility. */
#ifdef __GNUC__
#define _ATTRIBUTE(attrs) __attribute__ (attrs)
#else
#define _ATTRIBUTE(attrs)
#endif
/* The traditional meaning of 'extern inline' for GCC is not
to emit the function body unless the address is explicitly
taken. However this behaviour is changing to match the C99
standard, which uses 'extern inline' to indicate that the
function body *must* be emitted. If we are using GCC, but do
not have the new behaviour, we need to use extern inline; if
we are using a new GCC with the C99-compatible behaviour, or
a non-GCC compiler (which we will have to hope is C99, since
there is no other way to achieve the effect of omitting the
function if it isn't referenced) we just use plain 'inline',
which c99 defines to mean more-or-less the same as the Gnu C
'extern inline'. */
#if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__)
/* We're using GCC, but without the new C99-compatible behaviour. */
#define _ELIDABLE_INLINE extern __inline__ _ATTRIBUTE ((__always_inline__))
#else
/* We're using GCC in C99 mode, or an unknown compiler which
we just have to hope obeys the C99 semantics of inline. */
#define _ELIDABLE_INLINE __inline__
#endif
#endif /* _ANSIDECL_H_ */

40
programs/develop/libraries/newlib/include/_syslist.h Normal file
View File

@ -0,0 +1,40 @@
/* internal use only -- mapping of "system calls" for libraries that lose
and only provide C names, so that we end up in violation of ANSI */
#ifndef __SYSLIST_H
#define __SYSLIST_H
#ifdef MISSING_SYSCALL_NAMES
#define _close close
#define _execve execve
#define _fcntl fcntl
#define _fork fork
#define _fstat fstat
#define _getpid getpid
#define _gettimeofday gettimeofday
#define _isatty isatty
#define _kill kill
#define _link link
#define _lseek lseek
#define _mkdir mkdir
#define _open open
#define _read read
#define _sbrk sbrk
#define _stat stat
#define _times times
#define _unlink unlink
#define _wait wait
#define _write write
#endif /* MISSING_SYSCALL_NAMES */
#if defined MISSING_SYSCALL_NAMES || !defined HAVE_OPENDIR
/* If the system call interface is missing opendir, readdir, and
closedir, there is an implementation of these functions in
libc/posix that is implemented using open, getdents, and close.
Note, these functions are currently not in the libc/syscalls
directory. */
#define _opendir opendir
#define _readdir readdir
#define _closedir closedir
#endif /* MISSING_SYSCALL_NAMES || !HAVE_OPENDIR */
#endif /* !__SYSLIST_H_ */

21
programs/develop/libraries/newlib/include/alloca.h Normal file
View File

@ -0,0 +1,21 @@
/* libc/include/alloca.h - Allocate memory on stack */
/* Written 2000 by Werner Almesberger */
/* Rearranged for general inclusion by stdlib.h.
2001, Corinna Vinschen <vinschen@redhat.com> */
#ifndef _NEWLIB_ALLOCA_H
#define _NEWLIB_ALLOCA_H
#include "_ansi.h"
#include <sys/reent.h>
#undef alloca
#ifdef __GNUC__
#define alloca(size) __builtin_alloca(size)
#else
void * _EXFUN(alloca,(size_t));
#endif
#endif

69
programs/develop/libraries/newlib/include/ar.h Normal file
View File

@ -0,0 +1,69 @@
/* $NetBSD: ar.h,v 1.4 1994/10/26 00:55:43 cgd Exp $ */
/*-
* Copyright (c) 1991, 1993
* The Regents of the University of California. All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* This code is derived from software contributed to Berkeley by
* Hugh Smith at The University of Guelph.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)ar.h 8.2 (Berkeley) 1/21/94
*/
#ifndef _AR_H_
#define _AR_H_
/* Pre-4BSD archives had these magic numbers in them. */
#define OARMAG1 0177555
#define OARMAG2 0177545
#define ARMAG "!<arch>\n" /* ar "magic number" */
#define SARMAG 8 /* strlen(ARMAG); */
#define AR_EFMT1 "#1/" /* extended format #1 */
struct ar_hdr {
char ar_name[16]; /* name */
char ar_date[12]; /* modification time */
char ar_uid[6]; /* user id */
char ar_gid[6]; /* group id */
char ar_mode[8]; /* octal file permissions */
char ar_size[10]; /* size in bytes */
#define ARFMAG "`\n"
char ar_fmag[2]; /* consistency check */
};
#endif /* !_AR_H_ */

33
programs/develop/libraries/newlib/include/argz.h Normal file
View File

@ -0,0 +1,33 @@
/* Copyright (C) 2002 by Red Hat, Incorporated. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software
* is freely granted, provided that this notice is preserved.
*/
#ifndef _ARGZ_H_
#define _ARGZ_H_
#include <errno.h>
#include <sys/types.h>
#include "_ansi.h"
_BEGIN_STD_C
/* The newlib implementation of these functions assumes that sizeof(char) == 1. */
error_t argz_create (char *const argv[], char **argz, size_t *argz_len);
error_t argz_create_sep (const char *string, int sep, char **argz, size_t *argz_len);
size_t argz_count (const char *argz, size_t argz_len);
void argz_extract (char *argz, size_t argz_len, char **argv);
void argz_stringify (char *argz, size_t argz_len, int sep);
error_t argz_add (char **argz, size_t *argz_len, const char *str);
error_t argz_add_sep (char **argz, size_t *argz_len, const char *str, int sep);
error_t argz_append (char **argz, size_t *argz_len, const char *buf, size_t buf_len);
error_t argz_delete (char **argz, size_t *argz_len, char *entry);
error_t argz_insert (char **argz, size_t *argz_len, char *before, const char *entry);
char * argz_next (char *argz, size_t argz_len, const char *entry);
error_t argz_replace (char **argz, size_t *argz_len, const char *str, const char *with, unsigned *replace_count);
_END_STD_C
#endif /* _ARGZ_H_ */

50
programs/develop/libraries/newlib/include/assert.h Normal file
View File

@ -0,0 +1,50 @@
/*
assert.h
*/
#ifndef _NEWLIB_ASSERT_H
#define _NEWLIB_ASSERT_H
#ifdef __cplusplus
extern "C" {
#endif
#include "_ansi.h"
#undef assert
#ifdef NDEBUG /* required by ANSI standard */
# define assert(__e) ((void)0)
#else
# define assert(__e) ((__e) ? (void)0 : __assert_func (__FILE__, __LINE__, \
__ASSERT_FUNC, #__e))
# ifndef __ASSERT_FUNC
/* Use g++'s demangled names in C++. */
# if defined __cplusplus && defined __GNUC__
# define __ASSERT_FUNC __PRETTY_FUNCTION__
/* C99 requires the use of __func__. */
# elif __STDC_VERSION__ >= 199901L
# define __ASSERT_FUNC __func__
/* Older versions of gcc don't have __func__ but can use __FUNCTION__. */
# elif __GNUC__ >= 2
# define __ASSERT_FUNC __FUNCTION__
/* failed to detect __func__ support. */
# else
# define __ASSERT_FUNC ((char *) 0)
# endif
# endif /* !__ASSERT_FUNC */
#endif /* !NDEBUG */
void _EXFUN(__assert, (const char *, int, const char *)
_ATTRIBUTE ((__noreturn__)));
void _EXFUN(__assert_func, (const char *, int, const char *, const char *)
_ATTRIBUTE ((__noreturn__)));
#ifdef __cplusplus
}
#endif
#endif /* _NEWLIB_ASSERT_H */

124
programs/develop/libraries/newlib/include/complex.h Normal file
View File

@ -0,0 +1,124 @@
/* $NetBSD: complex.h,v 1.3 2010/09/15 16:11:30 christos Exp $ */
/*
* Written by Matthias Drochner.
* Public domain.
*/
#ifndef _COMPLEX_H
#define _COMPLEX_H
#define complex _Complex
#define _Complex_I 1.0fi
#define I _Complex_I
#include <sys/cdefs.h>
__BEGIN_DECLS
/* 7.3.5 Trigonometric functions */
/* 7.3.5.1 The cacos functions */
double complex cacos(double complex);
float complex cacosf(float complex);
/* 7.3.5.2 The casin functions */
double complex casin(double complex);
float complex casinf(float complex);
/* 7.3.5.1 The catan functions */
double complex catan(double complex);
float complex catanf(float complex);
/* 7.3.5.1 The ccos functions */
double complex ccos(double complex);
float complex ccosf(float complex);
/* 7.3.5.1 The csin functions */
double complex csin(double complex);
float complex csinf(float complex);
/* 7.3.5.1 The ctan functions */
double complex ctan(double complex);
float complex ctanf(float complex);
/* 7.3.6 Hyperbolic functions */
/* 7.3.6.1 The cacosh functions */
double complex cacosh(double complex);
float complex cacoshf(float complex);
/* 7.3.6.2 The casinh functions */
double complex casinh(double complex);
float complex casinhf(float complex);
/* 7.3.6.3 The catanh functions */
double complex catanh(double complex);
float complex catanhf(float complex);
/* 7.3.6.4 The ccosh functions */
double complex ccosh(double complex);
float complex ccoshf(float complex);
/* 7.3.6.5 The csinh functions */
double complex csinh(double complex);
float complex csinhf(float complex);
/* 7.3.6.6 The ctanh functions */
double complex ctanh(double complex);
float complex ctanhf(float complex);
/* 7.3.7 Exponential and logarithmic functions */
/* 7.3.7.1 The cexp functions */
double complex cexp(double complex);
float complex cexpf(float complex);
/* 7.3.7.2 The clog functions */
double complex clog(double complex);
float complex clogf(float complex);
/* 7.3.8 Power and absolute-value functions */
/* 7.3.8.1 The cabs functions */
/*#ifndef __LIBM0_SOURCE__
/* avoid conflict with historical cabs(struct complex) */
/* double cabs(double complex) __RENAME(__c99_cabs);
float cabsf(float complex) __RENAME(__c99_cabsf);
#endif
*/
double cabs(double complex) ;
float cabsf(float complex) ;
/* 7.3.8.2 The cpow functions */
double complex cpow(double complex, double complex);
float complex cpowf(float complex, float complex);
/* 7.3.8.3 The csqrt functions */
double complex csqrt(double complex);
float complex csqrtf(float complex);
/* 7.3.9 Manipulation functions */
/* 7.3.9.1 The carg functions */
double carg(double complex);
float cargf(float complex);
/* 7.3.9.2 The cimag functions */
double cimag(double complex);
float cimagf(float complex);
/*long double cimagl(long double complex); */
/* 7.3.9.3 The conj functions */
double complex conj(double complex);
float complex conjf(float complex);
/*long double complex conjl(long double complex); */
/* 7.3.9.4 The cproj functions */
double complex cproj(double complex);
float complex cprojf(float complex);
/*long double complex cprojl(long double complex); */
/* 7.3.9.5 The creal functions */
double creal(double complex);
float crealf(float complex);
/*long double creall(long double complex); */
__END_DECLS
#endif /* ! _COMPLEX_H */

113
programs/develop/libraries/newlib/include/ctype.h Normal file
View File

@ -0,0 +1,113 @@
#ifndef _CTYPE_H_
#define _CTYPE_H_
#include "_ansi.h"
_BEGIN_STD_C
int _EXFUN(isalnum, (int __c));
int _EXFUN(isalpha, (int __c));
int _EXFUN(iscntrl, (int __c));
int _EXFUN(isdigit, (int __c));
int _EXFUN(isgraph, (int __c));
int _EXFUN(islower, (int __c));
int _EXFUN(isprint, (int __c));
int _EXFUN(ispunct, (int __c));
int _EXFUN(isspace, (int __c));
int _EXFUN(isupper, (int __c));
int _EXFUN(isxdigit,(int __c));
int _EXFUN(tolower, (int __c));
int _EXFUN(toupper, (int __c));
#if !defined(__STRICT_ANSI__) || defined(__cplusplus) || __STDC_VERSION__ >= 199901L
int _EXFUN(isblank, (int __c));
#endif
#ifndef __STRICT_ANSI__
int _EXFUN(isascii, (int __c));
int _EXFUN(toascii, (int __c));
#define _tolower(__c) ((unsigned char)(__c) - 'A' + 'a')
#define _toupper(__c) ((unsigned char)(__c) - 'a' + 'A')
#endif
#define _U 01
#define _L 02
#define _N 04
#define _S 010
#define _P 020
#define _C 040
#define _X 0100
#define _B 0200
#ifndef _MB_CAPABLE
_CONST
#endif
extern __IMPORT char *__ctype_ptr__;
#ifndef __cplusplus
/* These macros are intentionally written in a manner that will trigger
a gcc -Wall warning if the user mistakenly passes a 'char' instead
of an int containing an 'unsigned char'. Note that the sizeof will
always be 1, which is what we want for mapping EOF to __ctype_ptr__[0];
the use of a raw index inside the sizeof triggers the gcc warning if
__c was of type char, and sizeof masks side effects of the extra __c.
Meanwhile, the real index to __ctype_ptr__+1 must be cast to int,
since isalpha(0x100000001LL) must equal isalpha(1), rather than being
an out-of-bounds reference on a 64-bit machine. */
#define __ctype_lookup(__c) ((__ctype_ptr__+sizeof(""[__c]))[(int)(__c)])
#define isalpha(__c) (__ctype_lookup(__c)&(_U|_L))
#define isupper(__c) ((__ctype_lookup(__c)&(_U|_L))==_U)
#define islower(__c) ((__ctype_lookup(__c)&(_U|_L))==_L)
#define isdigit(__c) (__ctype_lookup(__c)&_N)
#define isxdigit(__c) (__ctype_lookup(__c)&(_X|_N))
#define isspace(__c) (__ctype_lookup(__c)&_S)
#define ispunct(__c) (__ctype_lookup(__c)&_P)
#define isalnum(__c) (__ctype_lookup(__c)&(_U|_L|_N))
#define isprint(__c) (__ctype_lookup(__c)&(_P|_U|_L|_N|_B))
#define isgraph(__c) (__ctype_lookup(__c)&(_P|_U|_L|_N))
#define iscntrl(__c) (__ctype_lookup(__c)&_C)
#if defined(__GNUC__) && \
(!defined(__STRICT_ANSI__) || __STDC_VERSION__ >= 199901L)
#define isblank(__c) \
__extension__ ({ __typeof__ (__c) __x = (__c); \
(__ctype_lookup(__x)&_B) || (int) (__x) == '\t';})
#endif
/* Non-gcc versions will get the library versions, and will be
slightly slower. These macros are not NLS-aware so they are
disabled if the system supports the extended character sets. */
# if defined(__GNUC__)
# if !defined (_MB_EXTENDED_CHARSETS_ISO) && !defined (_MB_EXTENDED_CHARSETS_WINDOWS)
# define toupper(__c) \
__extension__ ({ __typeof__ (__c) __x = (__c); \
islower (__x) ? (int) __x - 'a' + 'A' : (int) __x;})
# define tolower(__c) \
__extension__ ({ __typeof__ (__c) __x = (__c); \
isupper (__x) ? (int) __x - 'A' + 'a' : (int) __x;})
# else /* _MB_EXTENDED_CHARSETS* */
/* Allow a gcc warning if the user passed 'char', but defer to the
function. */
# define toupper(__c) \
__extension__ ({ __typeof__ (__c) __x = (__c); \
(void) __ctype_ptr__[__x]; (toupper) (__x);})
# define tolower(__c) \
__extension__ ({ __typeof__ (__c) __x = (__c); \
(void) __ctype_ptr__[__x]; (tolower) (__x);})
# endif /* _MB_EXTENDED_CHARSETS* */
# endif /* __GNUC__ */
#endif /* !__cplusplus */
#ifndef __STRICT_ANSI__
#define isascii(__c) ((unsigned)(__c)<=0177)
#define toascii(__c) ((__c)&0177)
#endif
/* For C++ backward-compatibility only. */
extern __IMPORT _CONST char _ctype_[];
_END_STD_C
#endif /* _CTYPE_H_ */

15
programs/develop/libraries/newlib/include/dirent.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef _DIRENT_H_
#define _DIRENT_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/dirent.h>
#if !defined(MAXNAMLEN) && !defined(_POSIX_SOURCE)
#define MAXNAMLEN 1024
#endif
#ifdef __cplusplus
}
#endif
#endif /*_DIRENT_H_*/

15
programs/develop/libraries/newlib/include/envlock.h Normal file
View File

@ -0,0 +1,15 @@
/* envlock.h -- header file for env routines. */
#ifndef _INCLUDE_ENVLOCK_H_
#define _INCLUDE_ENVLOCK_H_
#include <_ansi.h>
#include <sys/reent.h>
#define ENV_LOCK __env_lock(reent_ptr)
#define ENV_UNLOCK __env_unlock(reent_ptr)
void _EXFUN(__env_lock,(struct _reent *reent));
void _EXFUN(__env_unlock,(struct _reent *reent));
#endif /* _INCLUDE_ENVLOCK_H_ */

16
programs/develop/libraries/newlib/include/envz.h Normal file
View File

@ -0,0 +1,16 @@
/* Copyright (C) 2002 by Red Hat, Incorporated. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software
* is freely granted, provided that this notice is preserved.
*/
#include <errno.h>
#include <sys/types.h>
/* The newlib implementation of these functions assumes that sizeof(char) == 1. */
char * envz_entry (const char *envz, size_t envz_len, const char *name);
char * envz_get (const char *envz, size_t envz_len, const char *name);
error_t envz_add (char **envz, size_t *envz_len, const char *name, const char *value);
error_t envz_merge (char **envz, size_t *envz_len, const char *envz2, size_t envz2_len, int override);
void envz_remove(char **envz, size_t *envz_len, const char *name);
void envz_strip (char **envz, size_t *envz_len);

11
programs/develop/libraries/newlib/include/errno.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __ERRNO_H__
#define __ERRNO_H__
#ifndef __error_t_defined
typedef int error_t;
#define __error_t_defined 1
#endif
#include <sys/errno.h>
#endif /* !__ERRNO_H__ */

13
programs/develop/libraries/newlib/include/fastmath.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _FASTMATH_H_
#ifdef __cplusplus
extern "C" {
#endif
#define _FASTMATH_H_
#include <math.h>
#include <machine/fastmath.h>
#ifdef __cplusplus
}
#endif
#endif /* _FASTMATH_H_ */

1
programs/develop/libraries/newlib/include/fcntl.h Normal file
View File

@ -0,0 +1 @@
#include <sys/fcntl.h>

55
programs/develop/libraries/newlib/include/fnmatch.h Normal file
View File

@ -0,0 +1,55 @@
/*-
* Copyright (c) 1992, 1993
* The Regents of the University of California. 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.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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: src/include/fnmatch.h,v 1.10 2002/03/23 17:24:53 imp Exp $
* @(#)fnmatch.h 8.1 (Berkeley) 6/2/93
*/
#ifndef _FNMATCH_H_
#define _FNMATCH_H_
#define FNM_NOMATCH 1 /* Match failed. */
#define FNM_NOESCAPE 0x01 /* Disable backslash escaping. */
#define FNM_PATHNAME 0x02 /* Slash must be matched by slash. */
#define FNM_PERIOD 0x04 /* Period must be matched by period. */
#if defined(_GNU_SOURCE) || !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE)
#define FNM_LEADING_DIR 0x08 /* Ignore /<tail> after Imatch. */
#define FNM_CASEFOLD 0x10 /* Case insensitive search. */
#define FNM_IGNORECASE FNM_CASEFOLD
#define FNM_FILE_NAME FNM_PATHNAME
#endif
#include <sys/cdefs.h>
__BEGIN_DECLS
int fnmatch(const char *, const char *, int);
__END_DECLS
#endif /* !_FNMATCH_H_ */

190
programs/develop/libraries/newlib/include/getopt.h Normal file
View File

@ -0,0 +1,190 @@
/****************************************************************************
getopt.h - Read command line options
AUTHOR: Gregory Pietsch
CREATED Thu Jan 09 22:37:00 1997
DESCRIPTION:
The getopt() function parses the command line arguments. Its arguments argc
and argv are the argument count and array as passed to the main() function
on program invocation. The argument optstring is a list of available option
characters. If such a character is followed by a colon (`:'), the option
takes an argument, which is placed in optarg. If such a character is
followed by two colons, the option takes an optional argument, which is
placed in optarg. If the option does not take an argument, optarg is NULL.
The external variable optind is the index of the next array element of argv
to be processed; it communicates from one call to the next which element to
process.
The getopt_long() function works like getopt() except that it also accepts
long options started by two dashes `--'. If these take values, it is either
in the form
--arg=value
or
--arg value
It takes the additional arguments longopts which is a pointer to the first
element of an array of type GETOPT_LONG_OPTION_T, defined below. The last
element of the array has to be filled with NULL for the name field.
The longind pointer points to the index of the current long option relative
to longopts if it is non-NULL.
The getopt() function returns the option character if the option was found
successfully, `:' if there was a missing parameter for one of the options,
`?' for an unknown option character, and EOF for the end of the option list.
The getopt_long() function's return value is described below.
The function getopt_long_only() is identical to getopt_long(), except that a
plus sign `+' can introduce long options as well as `--'.
Describe how to deal with options that follow non-option ARGV-elements.
If the caller did not specify anything, the default is REQUIRE_ORDER if the
environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise.
REQUIRE_ORDER means don't recognize them as options; stop option processing
when the first non-option is seen. This is what Unix does. This mode of
operation is selected by either setting the environment variable
POSIXLY_CORRECT, or using `+' as the first character of the optstring
parameter.
PERMUTE is the default. We permute the contents of ARGV as we scan, so that
eventually all the non-options are at the end. This allows options to be
given in any order, even with programs that were not written to expect this.
RETURN_IN_ORDER is an option available to programs that were written to
expect options and other ARGV-elements in any order and that care about the
ordering of the two. We describe each non-option ARGV-element as if it were
the argument of an option with character code 1. Using `-' as the first
character of the optstring parameter selects this mode of operation.
The special argument `--' forces an end of option-scanning regardless of the
value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause
getopt() and friends to return EOF with optind != argc.
COPYRIGHT NOTICE AND DISCLAIMER:
Copyright (C) 1997 Gregory Pietsch
This file and the accompanying getopt.c implementation file are hereby
placed in the public domain without restrictions. Just give the author
credit, don't claim you wrote it or prevent anyone else from using it.
Gregory Pietsch's current e-mail address:
gpietsch@comcast.net
****************************************************************************/
/* This is a glibc-extension header file. */
#ifndef GETOPT_H
#define GETOPT_H
#include <_ansi.h>
/* include files needed by this include file */
#define no_argument 0
#define required_argument 1
#define optional_argument 2
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* types defined by this include file */
struct option
{
char *name; /* the name of the long option */
int has_arg; /* one of the above macros */
int *flag; /* determines if getopt_long() returns a
* value for a long option; if it is
* non-NULL, 0 is returned as a function
* value and the value of val is stored in
* the area pointed to by flag. Otherwise,
* val is returned. */
int val; /* determines the value to return if flag is
* NULL. */
};
/* While getopt.h is a glibc extension, the following are newlib extensions.
* They are optionally included via the __need_getopt_newlib flag. */
#ifdef __need_getopt_newlib
/* macros defined by this include file */
#define NO_ARG no_argument
#define REQUIRED_ARG required_argument
#define OPTIONAL_ARG optional_argument
/* The GETOPT_DATA_INITIALIZER macro is used to initialize a statically-
allocated variable of type struct getopt_data. */
#define GETOPT_DATA_INITIALIZER {0,0,0,0,0}
/* These #defines are to make accessing the reentrant functions easier. */
#define getopt_r __getopt_r
#define getopt_long_r __getopt_long_r
#define getopt_long_only_r __getopt_long_only_r
/* The getopt_data structure is for reentrancy. Its members are similar to
the externally-defined variables. */
typedef struct getopt_data
{
char *optarg;
int optind, opterr, optopt, optwhere;
} getopt_data;
#endif /* __need_getopt_newlib */
/* externally-defined variables */
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;
/* function prototypes */
int _EXFUN (getopt,
(int __argc, char *const __argv[], const char *__optstring));
int _EXFUN (getopt_long,
(int __argc, char *const __argv[], const char *__shortopts,
const struct option * __longopts, int *__longind));
int _EXFUN (getopt_long_only,
(int __argc, char *const __argv[], const char *__shortopts,
const struct option * __longopts, int *__longind));
#ifdef __need_getopt_newlib
int _EXFUN (__getopt_r,
(int __argc, char *const __argv[], const char *__optstring,
struct getopt_data * __data));
int _EXFUN (__getopt_long_r,
(int __argc, char *const __argv[], const char *__shortopts,
const struct option * __longopts, int *__longind,
struct getopt_data * __data));
int _EXFUN (__getopt_long_only_r,
(int __argc, char *const __argv[], const char *__shortopts,
const struct option * __longopts, int *__longind,
struct getopt_data * __data));
#endif /* __need_getopt_newlib */
#ifdef __cplusplus
};
#endif /* __cplusplus */
#endif /* GETOPT_H */
/* END OF FILE getopt.h */

89
programs/develop/libraries/newlib/include/glob.h Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Guido van Rossum.
*
* 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.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)glob.h 8.1 (Berkeley) 6/2/93
* $FreeBSD: src/include/glob.h,v 1.6 2002/03/23 17:24:53 imp Exp $
*/
#ifndef _GLOB_H_
#define _GLOB_H_
#include <sys/cdefs.h>
struct stat;
typedef struct {
int gl_pathc; /* Count of total paths so far. */
int gl_matchc; /* Count of paths matching pattern. */
int gl_offs; /* Reserved at beginning of gl_pathv. */
int gl_flags; /* Copy of flags parameter to glob. */
char **gl_pathv; /* List of paths matching pattern. */
/* Copy of errfunc parameter to glob. */
int (*gl_errfunc)(const char *, int);
/*
* Alternate filesystem access methods for glob; replacement
* versions of closedir(3), readdir(3), opendir(3), stat(2)
* and lstat(2).
*/
void (*gl_closedir)(void *);
struct dirent *(*gl_readdir)(void *);
void *(*gl_opendir)(const char *);
int (*gl_lstat)(const char *, struct stat *);
int (*gl_stat)(const char *, struct stat *);
} glob_t;
#define GLOB_APPEND 0x0001 /* Append to output from previous call. */
#define GLOB_DOOFFS 0x0002 /* Use gl_offs. */
#define GLOB_ERR 0x0004 /* Return on error. */
#define GLOB_MARK 0x0008 /* Append / to matching directories. */
#define GLOB_NOCHECK 0x0010 /* Return pattern itself if nothing matches. */
#define GLOB_NOSORT 0x0020 /* Don't sort. */
#define GLOB_ALTDIRFUNC 0x0040 /* Use alternately specified directory funcs. */
#define GLOB_BRACE 0x0080 /* Expand braces ala csh. */
#define GLOB_MAGCHAR 0x0100 /* Pattern had globbing characters. */
#define GLOB_NOMAGIC 0x0200 /* GLOB_NOCHECK without magic chars (csh). */
#define GLOB_QUOTE 0x0400 /* Quote special chars with \. */
#define GLOB_TILDE 0x0800 /* Expand tilde names from the passwd file. */
#define GLOB_LIMIT 0x1000 /* limit number of returned paths */
/* backwards compatibility, this is the old name for this option */
#define GLOB_MAXPATH GLOB_LIMIT
#define GLOB_NOSPACE (-1) /* Malloc call failed. */
#define GLOB_ABEND (-2) /* Unignored error. */
__BEGIN_DECLS
int glob(const char *, int, int (*)(const char *, int), glob_t *);
void globfree(glob_t *);
__END_DECLS
#endif /* !_GLOB_H_ */

94
programs/develop/libraries/newlib/include/grp.h Normal file
View File

@ -0,0 +1,94 @@
/* $NetBSD: grp.h,v 1.7 1995/04/29 05:30:40 cgd Exp $ */
/*-
* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)grp.h 8.2 (Berkeley) 1/21/94
*/
#ifndef _GRP_H_
#define _GRP_H_
#include <sys/types.h>
#ifdef __CYGWIN__
#include <cygwin/grp.h>
#endif
#if !defined(_POSIX_SOURCE) && !defined(_XOPEN_SOURCE)
#define _PATH_GROUP "/etc/group"
#endif
struct group {
char *gr_name; /* group name */
char *gr_passwd; /* group password */
gid_t gr_gid; /* group id */
char **gr_mem; /* group members */
};
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __INSIDE_CYGWIN__
struct group *getgrgid (gid_t);
struct group *getgrnam (const char *);
int getgrnam_r (const char *, struct group *,
char *, size_t, struct group **);
int getgrgid_r (gid_t, struct group *,
char *, size_t, struct group **);
#ifndef _POSIX_SOURCE
struct group *getgrent (void);
void setgrent (void);
void endgrent (void);
#ifndef __CYGWIN__
void setgrfile (const char *);
#endif /* !__CYGWIN__ */
#ifndef _XOPEN_SOURCE
#ifndef __CYGWIN__
char *group_from_gid (gid_t, int);
int setgroupent (int);
#endif /* !__CYGWIN__ */
int initgroups (const char *, gid_t);
#endif /* !_XOPEN_SOURCE */
#endif /* !_POSIX_SOURCE */
#endif /* !__INSIDE_CYGWIN__ */
#ifdef __cplusplus
}
#endif
#endif /* !_GRP_H_ */

62
programs/develop/libraries/newlib/include/iconv.h Normal file
View File

@ -0,0 +1,62 @@
/*
* Copyright (c) 2003-2004, Artem B. Bityuckiy, SoftMine Corporation.
* Rights transferred to Franklin Electronic Publishers.
*
* 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.
*/
#ifndef _ICONV_H_
#define _ICONV_H_
#include <_ansi.h>
#include <reent.h>
#include <sys/types.h>
#include <sys/_types.h>
/* iconv_t: charset conversion descriptor type */
typedef _iconv_t iconv_t;
_BEGIN_STD_C
#ifndef _REENT_ONLY
iconv_t
_EXFUN(iconv_open, (_CONST char *, _CONST char *));
size_t
_EXFUN(iconv, (iconv_t, char **, size_t *, char **, size_t *));
int
_EXFUN(iconv_close, (iconv_t));
#endif
iconv_t
_EXFUN(_iconv_open_r, (struct _reent *, _CONST char *, _CONST char *));
size_t
_EXFUN(_iconv_r, (struct _reent *, iconv_t, _CONST char **,
size_t *, char **, size_t *));
int
_EXFUN(_iconv_close_r, (struct _reent *, iconv_t));
_END_STD_C
#endif /* #ifndef _ICONV_H_ */

256
programs/develop/libraries/newlib/include/ieeefp.h Normal file
View File

@ -0,0 +1,256 @@
#ifndef _IEEE_FP_H_
#define _IEEE_FP_H_
#include "_ansi.h"
#include <machine/ieeefp.h>
_BEGIN_STD_C
/* FIXME FIXME FIXME:
Neither of __ieee_{float,double}_shape_tape seem to be used anywhere
except in libm/test. If that is the case, please delete these from here.
If that is not the case, please insert documentation here describing why
they're needed. */
#ifdef __IEEE_BIG_ENDIAN
typedef union
{
double value;
struct
{
unsigned int sign : 1;
unsigned int exponent: 11;
unsigned int fraction0:4;
unsigned int fraction1:16;
unsigned int fraction2:16;
unsigned int fraction3:16;
} number;
struct
{
unsigned int sign : 1;
unsigned int exponent: 11;
unsigned int quiet:1;
unsigned int function0:3;
unsigned int function1:16;
unsigned int function2:16;
unsigned int function3:16;
} nan;
struct
{
unsigned long msw;
unsigned long lsw;
} parts;
long aslong[2];
} __ieee_double_shape_type;
#endif
#ifdef __IEEE_LITTLE_ENDIAN
typedef union
{
double value;
struct
{
#ifdef __SMALL_BITFIELDS
unsigned int fraction3:16;
unsigned int fraction2:16;
unsigned int fraction1:16;
unsigned int fraction0: 4;
#else
unsigned int fraction1:32;
unsigned int fraction0:20;
#endif
unsigned int exponent :11;
unsigned int sign : 1;
} number;
struct
{
#ifdef __SMALL_BITFIELDS
unsigned int function3:16;
unsigned int function2:16;
unsigned int function1:16;
unsigned int function0:3;
#else
unsigned int function1:32;
unsigned int function0:19;
#endif
unsigned int quiet:1;
unsigned int exponent: 11;
unsigned int sign : 1;
} nan;
struct
{
unsigned long lsw;
unsigned long msw;
} parts;
long aslong[2];
} __ieee_double_shape_type;
#endif
#ifdef __IEEE_BIG_ENDIAN
typedef union
{
float value;
struct
{
unsigned int sign : 1;
unsigned int exponent: 8;
unsigned int fraction0: 7;
unsigned int fraction1: 16;
} number;
struct
{
unsigned int sign:1;
unsigned int exponent:8;
unsigned int quiet:1;
unsigned int function0:6;
unsigned int function1:16;
} nan;
long p1;
} __ieee_float_shape_type;
#endif
#ifdef __IEEE_LITTLE_ENDIAN
typedef union
{
float value;
struct
{
unsigned int fraction0: 7;
unsigned int fraction1: 16;
unsigned int exponent: 8;
unsigned int sign : 1;
} number;
struct
{
unsigned int function1:16;
unsigned int function0:6;
unsigned int quiet:1;
unsigned int exponent:8;
unsigned int sign:1;
} nan;
long p1;
} __ieee_float_shape_type;
#endif
/* FLOATING ROUNDING */
typedef int fp_rnd;
#define FP_RN 0 /* Round to nearest */
#define FP_RM 1 /* Round down */
#define FP_RP 2 /* Round up */
#define FP_RZ 3 /* Round to zero (trunate) */
fp_rnd _EXFUN(fpgetround,(void));
fp_rnd _EXFUN(fpsetround, (fp_rnd));
/* EXCEPTIONS */
typedef int fp_except;
#define FP_X_INV 0x10 /* Invalid operation */
#define FP_X_DX 0x80 /* Divide by zero */
#define FP_X_OFL 0x04 /* Overflow exception */
#define FP_X_UFL 0x02 /* Underflow exception */
#define FP_X_IMP 0x01 /* imprecise exception */
fp_except _EXFUN(fpgetmask,(void));
fp_except _EXFUN(fpsetmask,(fp_except));
fp_except _EXFUN(fpgetsticky,(void));
fp_except _EXFUN(fpsetsticky, (fp_except));
/* INTEGER ROUNDING */
typedef int fp_rdi;
#define FP_RDI_TOZ 0 /* Round to Zero */
#define FP_RDI_RD 1 /* Follow float mode */
fp_rdi _EXFUN(fpgetroundtoi,(void));
fp_rdi _EXFUN(fpsetroundtoi,(fp_rdi));
#undef isnan
#undef isinf
int _EXFUN(isnan, (double));
int _EXFUN(isinf, (double));
int _EXFUN(finite, (double));
int _EXFUN(isnanf, (float));
int _EXFUN(isinff, (float));
int _EXFUN(finitef, (float));
#define __IEEE_DBL_EXPBIAS 1023
#define __IEEE_FLT_EXPBIAS 127
#define __IEEE_DBL_EXPLEN 11
#define __IEEE_FLT_EXPLEN 8
#define __IEEE_DBL_FRACLEN (64 - (__IEEE_DBL_EXPLEN + 1))
#define __IEEE_FLT_FRACLEN (32 - (__IEEE_FLT_EXPLEN + 1))
#define __IEEE_DBL_MAXPOWTWO ((double)(1L << 32 - 2) * (1L << (32-11) - 32 + 1))
#define __IEEE_FLT_MAXPOWTWO ((float)(1L << (32-8) - 1))
#define __IEEE_DBL_NAN_EXP 0x7ff
#define __IEEE_FLT_NAN_EXP 0xff
#ifndef __ieeefp_isnanf
#define __ieeefp_isnanf(x) (((*(long *)&(x) & 0x7f800000L)==0x7f800000L) && \
((*(long *)&(x) & 0x007fffffL)!=0000000000L))
#endif
#define isnanf(x) __ieeefp_isnanf(x)
#ifndef __ieeefp_isinff
#define __ieeefp_isinff(x) (((*(long *)&(x) & 0x7f800000L)==0x7f800000L) && \
((*(long *)&(x) & 0x007fffffL)==0000000000L))
#endif
#define isinff(x) __ieeefp_isinff(x)
#ifndef __ieeefp_finitef
#define __ieeefp_finitef(x) (((*(long *)&(x) & 0x7f800000L)!=0x7f800000L))
#endif
#define finitef(x) __ieeefp_finitef(x)
#ifdef _DOUBLE_IS_32BITS
#undef __IEEE_DBL_EXPBIAS
#define __IEEE_DBL_EXPBIAS __IEEE_FLT_EXPBIAS
#undef __IEEE_DBL_EXPLEN
#define __IEEE_DBL_EXPLEN __IEEE_FLT_EXPLEN
#undef __IEEE_DBL_FRACLEN
#define __IEEE_DBL_FRACLEN __IEEE_FLT_FRACLEN
#undef __IEEE_DBL_MAXPOWTWO
#define __IEEE_DBL_MAXPOWTWO __IEEE_FLT_MAXPOWTWO
#undef __IEEE_DBL_NAN_EXP
#define __IEEE_DBL_NAN_EXP __IEEE_FLT_NAN_EXP
#undef __ieee_double_shape_type
#define __ieee_double_shape_type __ieee_float_shape_type
#endif /* _DOUBLE_IS_32BITS */
_END_STD_C
#endif /* _IEEE_FP_H_ */

290
programs/develop/libraries/newlib/include/inttypes.h Normal file
View File

@ -0,0 +1,290 @@
/*
* Copyright (c) 2004, 2005 by
* Ralf Corsepius, Ulm/Germany. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software
* is freely granted, provided that this notice is preserved.
*/
/**
* @file inttypes.h
*/
#ifndef _INTTYPES_H
#define _INTTYPES_H
#include <stdint.h>
#define __need_wchar_t
#include <stddef.h>
#define __STRINGIFY(a) #a
/* 8-bit types */
#define __PRI8(x) __STRINGIFY(x)
#define __SCN8(x) __STRINGIFY(hh##x)
#define PRId8 __PRI8(d)
#define PRIi8 __PRI8(i)
#define PRIo8 __PRI8(o)
#define PRIu8 __PRI8(u)
#define PRIx8 __PRI8(x)
#define PRIX8 __PRI8(X)
#define SCNd8 __SCN8(d)
#define SCNi8 __SCN8(i)
#define SCNo8 __SCN8(o)
#define SCNu8 __SCN8(u)
#define SCNx8 __SCN8(x)
#define PRIdLEAST8 __PRI8(d)
#define PRIiLEAST8 __PRI8(i)
#define PRIoLEAST8 __PRI8(o)
#define PRIuLEAST8 __PRI8(u)
#define PRIxLEAST8 __PRI8(x)
#define PRIXLEAST8 __PRI8(X)
#define SCNdLEAST8 __SCN8(d)
#define SCNiLEAST8 __SCN8(i)
#define SCNoLEAST8 __SCN8(o)
#define SCNuLEAST8 __SCN8(u)
#define SCNxLEAST8 __SCN8(x)
#define PRIdFAST8 __PRI8(d)
#define PRIiFAST8 __PRI8(i)
#define PRIoFAST8 __PRI8(o)
#define PRIuFAST8 __PRI8(u)
#define PRIxFAST8 __PRI8(x)
#define PRIXFAST8 __PRI8(X)
#define SCNdFAST8 __SCN8(d)
#define SCNiFAST8 __SCN8(i)
#define SCNoFAST8 __SCN8(o)
#define SCNuFAST8 __SCN8(u)
#define SCNxFAST8 __SCN8(x)
/* 16-bit types */
#define __PRI16(x) __STRINGIFY(x)
#define __SCN16(x) __STRINGIFY(h##x)
#define PRId16 __PRI16(d)
#define PRIi16 __PRI16(i)
#define PRIo16 __PRI16(o)
#define PRIu16 __PRI16(u)
#define PRIx16 __PRI16(x)
#define PRIX16 __PRI16(X)
#define SCNd16 __SCN16(d)
#define SCNi16 __SCN16(i)
#define SCNo16 __SCN16(o)
#define SCNu16 __SCN16(u)
#define SCNx16 __SCN16(x)
#define PRIdLEAST16 __PRI16(d)
#define PRIiLEAST16 __PRI16(i)
#define PRIoLEAST16 __PRI16(o)
#define PRIuLEAST16 __PRI16(u)
#define PRIxLEAST16 __PRI16(x)
#define PRIXLEAST16 __PRI16(X)
#define SCNdLEAST16 __SCN16(d)
#define SCNiLEAST16 __SCN16(i)
#define SCNoLEAST16 __SCN16(o)
#define SCNuLEAST16 __SCN16(u)
#define SCNxLEAST16 __SCN16(x)
#define PRIdFAST16 __PRI16(d)
#define PRIiFAST16 __PRI16(i)
#define PRIoFAST16 __PRI16(o)
#define PRIuFAST16 __PRI16(u)
#define PRIxFAST16 __PRI16(x)
#define PRIXFAST16 __PRI16(X)
#define SCNdFAST16 __SCN16(d)
#define SCNiFAST16 __SCN16(i)
#define SCNoFAST16 __SCN16(o)
#define SCNuFAST16 __SCN16(u)
#define SCNxFAST16 __SCN16(x)
/* 32-bit types */
#if __have_long32
#define __PRI32(x) __STRINGIFY(l##x)
#define __SCN32(x) __STRINGIFY(l##x)
#else
#define __PRI32(x) __STRINGIFY(x)
#define __SCN32(x) __STRINGIFY(x)
#endif
#define PRId32 __PRI32(d)
#define PRIi32 __PRI32(i)
#define PRIo32 __PRI32(o)
#define PRIu32 __PRI32(u)
#define PRIx32 __PRI32(x)
#define PRIX32 __PRI32(X)
#define SCNd32 __SCN32(d)
#define SCNi32 __SCN32(i)
#define SCNo32 __SCN32(o)
#define SCNu32 __SCN32(u)
#define SCNx32 __SCN32(x)
#define PRIdLEAST32 __PRI32(d)
#define PRIiLEAST32 __PRI32(i)
#define PRIoLEAST32 __PRI32(o)
#define PRIuLEAST32 __PRI32(u)
#define PRIxLEAST32 __PRI32(x)
#define PRIXLEAST32 __PRI32(X)
#define SCNdLEAST32 __SCN32(d)
#define SCNiLEAST32 __SCN32(i)
#define SCNoLEAST32 __SCN32(o)
#define SCNuLEAST32 __SCN32(u)
#define SCNxLEAST32 __SCN32(x)
#define PRIdFAST32 __PRI32(d)
#define PRIiFAST32 __PRI32(i)
#define PRIoFAST32 __PRI32(o)
#define PRIuFAST32 __PRI32(u)
#define PRIxFAST32 __PRI32(x)
#define PRIXFAST32 __PRI32(X)
#define SCNdFAST32 __SCN32(d)
#define SCNiFAST32 __SCN32(i)
#define SCNoFAST32 __SCN32(o)
#define SCNuFAST32 __SCN32(u)
#define SCNxFAST32 __SCN32(x)
/* 64-bit types */
#if __have_long64
#define __PRI64(x) __STRINGIFY(l##x)
#define __SCN64(x) __STRINGIFY(l##x)
#elif __have_longlong64
#define __PRI64(x) __STRINGIFY(ll##x)
#define __SCN64(x) __STRINGIFY(ll##x)
#else
#define __PRI64(x) __STRINGIFY(x)
#define __SCN64(x) __STRINGIFY(x)
#endif
#define PRId64 __PRI64(d)
#define PRIi64 __PRI64(i)
#define PRIo64 __PRI64(o)
#define PRIu64 __PRI64(u)
#define PRIx64 __PRI64(x)
#define PRIX64 __PRI64(X)
#define SCNd64 __SCN64(d)
#define SCNi64 __SCN64(i)
#define SCNo64 __SCN64(o)
#define SCNu64 __SCN64(u)
#define SCNx64 __SCN64(x)
#if __int64_t_defined
#define PRIdLEAST64 __PRI64(d)
#define PRIiLEAST64 __PRI64(i)
#define PRIoLEAST64 __PRI64(o)
#define PRIuLEAST64 __PRI64(u)
#define PRIxLEAST64 __PRI64(x)
#define PRIXLEAST64 __PRI64(X)
#define SCNdLEAST64 __SCN64(d)
#define SCNiLEAST64 __SCN64(i)
#define SCNoLEAST64 __SCN64(o)
#define SCNuLEAST64 __SCN64(u)
#define SCNxLEAST64 __SCN64(x)
#define PRIdFAST64 __PRI64(d)
#define PRIiFAST64 __PRI64(i)
#define PRIoFAST64 __PRI64(o)
#define PRIuFAST64 __PRI64(u)
#define PRIxFAST64 __PRI64(x)
#define PRIXFAST64 __PRI64(X)
#define SCNdFAST64 __SCN64(d)
#define SCNiFAST64 __SCN64(i)
#define SCNoFAST64 __SCN64(o)
#define SCNuFAST64 __SCN64(u)
#define SCNxFAST64 __SCN64(x)
#endif
/* max-bit types */
#if __have_long64
#define __PRIMAX(x) __STRINGIFY(l##x)
#define __SCNMAX(x) __STRINGIFY(l##x)
#elif __have_longlong64
#define __PRIMAX(x) __STRINGIFY(ll##x)
#define __SCNMAX(x) __STRINGIFY(ll##x)
#else
#define __PRIMAX(x) __STRINGIFY(x)
#define __SCNMAX(x) __STRINGIFY(x)
#endif
#define PRIdMAX __PRIMAX(d)
#define PRIiMAX __PRIMAX(i)
#define PRIoMAX __PRIMAX(o)
#define PRIuMAX __PRIMAX(u)
#define PRIxMAX __PRIMAX(x)
#define PRIXMAX __PRIMAX(X)
#define SCNdMAX __SCNMAX(d)
#define SCNiMAX __SCNMAX(i)
#define SCNoMAX __SCNMAX(o)
#define SCNuMAX __SCNMAX(u)
#define SCNxMAX __SCNMAX(x)
/* ptr types */
#if __have_long64
#define __PRIPTR(x) __STRINGIFY(l##x)
#define __SCNPTR(x) __STRINGIFY(l##x)
#elif __have_longlong64
#define __PRIPTR(x) __STRINGIFY(ll##x)
#define __SCNPTR(x) __STRINGIFY(ll##x)
#else
#define __PRIPTR(x) __STRINGIFY(x)
#define __SCNPTR(x) __STRINGIFY(x)
#endif
#define PRIdPTR __PRIPTR(d)
#define PRIiPTR __PRIPTR(i)
#define PRIoPTR __PRIPTR(o)
#define PRIuPTR __PRIPTR(u)
#define PRIxPTR __PRIPTR(x)
#define PRIXPTR __PRIPTR(X)
#define SCNdPTR __SCNPTR(d)
#define SCNiPTR __SCNPTR(i)
#define SCNoPTR __SCNPTR(o)
#define SCNuPTR __SCNPTR(u)
#define SCNxPTR __SCNPTR(x)
typedef struct {
intmax_t quot;
intmax_t rem;
} imaxdiv_t;
#ifdef __cplusplus
extern "C" {
#endif
extern intmax_t imaxabs(intmax_t j);
extern imaxdiv_t imaxdiv(intmax_t numer, intmax_t denomer);
extern intmax_t strtoimax(const char *__restrict, char **__restrict, int);
extern uintmax_t strtoumax(const char *__restrict, char **__restrict, int);
extern intmax_t wcstoimax(const wchar_t *__restrict, wchar_t **__restrict, int);
extern uintmax_t wcstoumax(const wchar_t *__restrict, wchar_t **__restrict, int);
#ifdef __cplusplus
}
#endif
#endif

316
programs/develop/libraries/newlib/include/langinfo.h Normal file
View File

@ -0,0 +1,316 @@
/*-
* Copyright (c) 2001 Alexey Zelkin <phantom@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: src/include/langinfo.h,v 1.5 2002/03/23 17:24:53 imp Exp $
*/
#ifndef _LANGINFO_H_
#define _LANGINFO_H_
#include <newlib.h>
#include <sys/config.h>
#include <sys/cdefs.h>
typedef int nl_item;
enum __nl_item
{
/* POSIX and BSD defined items have to stick to the original values
to maintain backward compatibility. */
_NL_CTYPE_CODESET_NAME = 0, /* codeset name */
#define CODESET _NL_CTYPE_CODESET_NAME
D_T_FMT, /* string for formatting date and time */
#define D_T_FMT D_T_FMT
D_FMT, /* date format string */
#define D_FMT D_FMT
T_FMT, /* time format string */
#define T_FMT T_FMT
T_FMT_AMPM, /* a.m. or p.m. time formatting string */
#define T_FMT_AMPM T_FMT_AMPM
AM_STR, /* Ante Meridian affix */
#define AM_STR AM_STR
PM_STR, /* Post Meridian affix */
#define PM_STR PM_STR
/* week day names */
DAY_1,
#define DAY_1 DAY_1
DAY_2,
#define DAY_2 DAY_2
DAY_3,
#define DAY_3 DAY_3
DAY_4,
#define DAY_4 DAY_4
DAY_5,
#define DAY_5 DAY_5
DAY_6,
#define DAY_6 DAY_6
DAY_7,
#define DAY_7 DAY_7
/* abbreviated week day names */
ABDAY_1,
#define ABDAY_1 ABDAY_1
ABDAY_2,
#define ABDAY_2 ABDAY_2
ABDAY_3,
#define ABDAY_3 ABDAY_3
ABDAY_4,
#define ABDAY_4 ABDAY_4
ABDAY_5,
#define ABDAY_5 ABDAY_5
ABDAY_6,
#define ABDAY_6 ABDAY_6
ABDAY_7,
#define ABDAY_7 ABDAY_7
/* month names */
MON_1,
#define MON_1 MON_1
MON_2,
#define MON_2 MON_2
MON_3,
#define MON_3 MON_3
MON_4,
#define MON_4 MON_4
MON_5,
#define MON_5 MON_5
MON_6,
#define MON_6 MON_6
MON_7,
#define MON_7 MON_7
MON_8,
#define MON_8 MON_8
MON_9,
#define MON_9 MON_9
MON_10,
#define MON_10 MON_10
MON_11,
#define MON_11 MON_11
MON_12,
#define MON_12 MON_12
/* abbreviated month names */
ABMON_1,
#define ABMON_1 ABMON_1
ABMON_2,
#define ABMON_2 ABMON_2
ABMON_3,
#define ABMON_3 ABMON_3
ABMON_4,
#define ABMON_4 ABMON_4
ABMON_5,
#define ABMON_5 ABMON_5
ABMON_6,
#define ABMON_6 ABMON_6
ABMON_7,
#define ABMON_7 ABMON_7
ABMON_8,
#define ABMON_8 ABMON_8
ABMON_9,
#define ABMON_9 ABMON_9
ABMON_10,
#define ABMON_10 ABMON_10
ABMON_11,
#define ABMON_11 ABMON_11
ABMON_12,
#define ABMON_12 ABMON_12
ERA, /* era description segments */
#define ERA ERA
ERA_D_FMT, /* era date format string */
#define ERA_D_FMT ERA_D_FMT
ERA_D_T_FMT, /* era date and time format string */
#define ERA_D_T_FMT ERA_D_T_FMT
ERA_T_FMT, /* era time format string */
#define ERA_T_FMT ERA_T_FMT
ALT_DIGITS, /* alternative symbols for digits */
#define ALT_DIGITS ALT_DIGITS
RADIXCHAR, /* radix char */
#define RADIXCHAR RADIXCHAR
THOUSEP, /* separator for thousands */
#define THOUSEP THOUSEP
YESEXPR, /* affirmative response expression */
#define YESEXPR YESEXPR
NOEXPR, /* negative response expression */
#define NOEXPR NOEXPR
YESSTR, /* affirmative response for yes/no queries */
#define YESSTR YESSTR
NOSTR, /* negative response for yes/no queries */
#define NOSTR NOSTR
CRNCYSTR, /* currency symbol */
#define CRNCYSTR CRNCYSTR
D_MD_ORDER, /* month/day order (BSD extension) */
#define D_MD_ORDER D_MD_ORDER
_NL_TIME_DATE_FMT = 84, /* date fmt used by date(1) (GNU extension) */
#define _DATE_FMT _NL_TIME_DATE_FMT
#ifdef __HAVE_LOCALE_INFO__
_NL_CTYPE_MB_CUR_MAX,
_NL_MESSAGES_CODESET,
#ifdef __HAVE_LOCALE_INFO_EXTENDED__
/* NOTE:
Always maintain the order and position of existing entries!
Always append new entry to the list, prior to the definition
of _NL_LOCALE_EXTENDED_LAST_ENTRY. */
_NL_LOCALE_EXTENDED_FIRST_ENTRY,
_NL_CTYPE_OUTDIGITS0_MB,
_NL_CTYPE_OUTDIGITS1_MB,
_NL_CTYPE_OUTDIGITS2_MB,
_NL_CTYPE_OUTDIGITS3_MB,
_NL_CTYPE_OUTDIGITS4_MB,
_NL_CTYPE_OUTDIGITS5_MB,
_NL_CTYPE_OUTDIGITS6_MB,
_NL_CTYPE_OUTDIGITS7_MB,
_NL_CTYPE_OUTDIGITS8_MB,
_NL_CTYPE_OUTDIGITS9_MB,
_NL_CTYPE_OUTDIGITS0_WC,
_NL_CTYPE_OUTDIGITS1_WC,
_NL_CTYPE_OUTDIGITS2_WC,
_NL_CTYPE_OUTDIGITS3_WC,
_NL_CTYPE_OUTDIGITS4_WC,
_NL_CTYPE_OUTDIGITS5_WC,
_NL_CTYPE_OUTDIGITS6_WC,
_NL_CTYPE_OUTDIGITS7_WC,
_NL_CTYPE_OUTDIGITS8_WC,
_NL_CTYPE_OUTDIGITS9_WC,
_NL_TIME_CODESET,
_NL_TIME_WMON_1,
_NL_TIME_WMON_2,
_NL_TIME_WMON_3,
_NL_TIME_WMON_4,
_NL_TIME_WMON_5,
_NL_TIME_WMON_6,
_NL_TIME_WMON_7,
_NL_TIME_WMON_8,
_NL_TIME_WMON_9,
_NL_TIME_WMON_10,
_NL_TIME_WMON_11,
_NL_TIME_WMON_12,
_NL_TIME_WMONTH_1,
_NL_TIME_WMONTH_2,
_NL_TIME_WMONTH_3,
_NL_TIME_WMONTH_4,
_NL_TIME_WMONTH_5,
_NL_TIME_WMONTH_6,
_NL_TIME_WMONTH_7,
_NL_TIME_WMONTH_8,
_NL_TIME_WMONTH_9,
_NL_TIME_WMONTH_10,
_NL_TIME_WMONTH_11,
_NL_TIME_WMONTH_12,
_NL_TIME_WWDAY_1,
_NL_TIME_WWDAY_2,
_NL_TIME_WWDAY_3,
_NL_TIME_WWDAY_4,
_NL_TIME_WWDAY_5,
_NL_TIME_WWDAY_6,
_NL_TIME_WWDAY_7,
_NL_TIME_WWEEKDAY_1,
_NL_TIME_WWEEKDAY_2,
_NL_TIME_WWEEKDAY_3,
_NL_TIME_WWEEKDAY_4,
_NL_TIME_WWEEKDAY_5,
_NL_TIME_WWEEKDAY_6,
_NL_TIME_WWEEKDAY_7,
_NL_TIME_WT_FMT,
_NL_TIME_WD_FMT,
_NL_TIME_WD_T_FMT,
_NL_TIME_WAM_STR,
_NL_TIME_WPM_STR,
_NL_TIME_WDATE_FMT,
_NL_TIME_WT_FMT_AMPM,
_NL_TIME_WERA,
_NL_TIME_WERA_D_FMT,
_NL_TIME_WERA_D_T_FMT,
_NL_TIME_WERA_T_FMT,
_NL_TIME_WALT_DIGITS,
_NL_NUMERIC_CODESET,
_NL_NUMERIC_GROUPING,
_NL_NUMERIC_DECIMAL_POINT_WC,
_NL_NUMERIC_THOUSANDS_SEP_WC,
_NL_MONETARY_INT_CURR_SYMBOL,
_NL_MONETARY_CURRENCY_SYMBOL,
_NL_MONETARY_MON_DECIMAL_POINT,
_NL_MONETARY_MON_THOUSANDS_SEP,
_NL_MONETARY_MON_GROUPING,
_NL_MONETARY_POSITIVE_SIGN,
_NL_MONETARY_NEGATIVE_SIGN,
_NL_MONETARY_INT_FRAC_DIGITS,
_NL_MONETARY_FRAC_DIGITS,
_NL_MONETARY_P_CS_PRECEDES,
_NL_MONETARY_P_SEP_BY_SPACE,
_NL_MONETARY_N_CS_PRECEDES,
_NL_MONETARY_N_SEP_BY_SPACE,
_NL_MONETARY_P_SIGN_POSN,
_NL_MONETARY_N_SIGN_POSN,
_NL_MONETARY_INT_P_CS_PRECEDES,
_NL_MONETARY_INT_P_SEP_BY_SPACE,
_NL_MONETARY_INT_N_CS_PRECEDES,
_NL_MONETARY_INT_N_SEP_BY_SPACE,
_NL_MONETARY_INT_P_SIGN_POSN,
_NL_MONETARY_INT_N_SIGN_POSN,
_NL_MONETARY_CODESET,
_NL_MONETARY_WINT_CURR_SYMBOL,
_NL_MONETARY_WCURRENCY_SYMBOL,
_NL_MONETARY_WMON_DECIMAL_POINT,
_NL_MONETARY_WMON_THOUSANDS_SEP,
_NL_MONETARY_WPOSITIVE_SIGN,
_NL_MONETARY_WNEGATIVE_SIGN,
_NL_MESSAGES_WYESEXPR,
_NL_MESSAGES_WNOEXPR,
_NL_MESSAGES_WYESSTR,
_NL_MESSAGES_WNOSTR,
_NL_COLLATE_CODESET,
/* This MUST be the last entry since it's used to check for an array
index in nl_langinfo(). */
_NL_LOCALE_EXTENDED_LAST_ENTRY
#endif /* __HAVE_LOCALE_INFO_EXTENDED__ */
#endif /* __HAVE_LOCALE_INFO__ */
};
__BEGIN_DECLS
char *nl_langinfo(nl_item);
__END_DECLS
#endif /* !_LANGINFO_H_ */

23
programs/develop/libraries/newlib/include/libgen.h Normal file
View File

@ -0,0 +1,23 @@
/*
* libgen.h - defined by XPG4
*/
#ifndef _LIBGEN_H_
#define _LIBGEN_H_
#include "_ansi.h"
#include <sys/reent.h>
#ifdef __cplusplus
extern "C" {
#endif
char *_EXFUN(basename, (char *));
char *_EXFUN(dirname, (char *));
#ifdef __cplusplus
}
#endif
#endif /* _LIBGEN_H_ */

146
programs/develop/libraries/newlib/include/limits.h Normal file
View File

@ -0,0 +1,146 @@
#ifndef _LIBC_LIMITS_H_
# define _LIBC_LIMITS_H_ 1
#include <newlib.h>
# ifdef _MB_LEN_MAX
# define MB_LEN_MAX _MB_LEN_MAX
# else
# define MB_LEN_MAX 1
# endif
/* Maximum number of positional arguments, if _WANT_IO_POS_ARGS. */
# ifndef NL_ARGMAX
# define NL_ARGMAX 32
# endif
/* if do not have #include_next support, then we
have to define the limits here. */
# if !defined __GNUC__ || __GNUC__ < 2
# ifndef _LIMITS_H
# define _LIMITS_H 1
# include <sys/config.h>
/* Number of bits in a `char'. */
# undef CHAR_BIT
# define CHAR_BIT 8
/* Minimum and maximum values a `signed char' can hold. */
# undef SCHAR_MIN
# define SCHAR_MIN (-128)
# undef SCHAR_MAX
# define SCHAR_MAX 127
/* Maximum value an `unsigned char' can hold. (Minimum is 0). */
# undef UCHAR_MAX
# define UCHAR_MAX 255
/* Minimum and maximum values a `char' can hold. */
# ifdef __CHAR_UNSIGNED__
# undef CHAR_MIN
# define CHAR_MIN 0
# undef CHAR_MAX
# define CHAR_MAX 255
# else
# undef CHAR_MIN
# define CHAR_MIN (-128)
# undef CHAR_MAX
# define CHAR_MAX 127
# endif
/* Minimum and maximum values a `signed short int' can hold. */
# undef SHRT_MIN
/* For the sake of 16 bit hosts, we may not use -32768 */
# define SHRT_MIN (-32767-1)
# undef SHRT_MAX
# define SHRT_MAX 32767
/* Maximum value an `unsigned short int' can hold. (Minimum is 0). */
# undef USHRT_MAX
# define USHRT_MAX 65535
/* Minimum and maximum values a `signed int' can hold. */
# ifndef __INT_MAX__
# define __INT_MAX__ 2147483647
# endif
# undef INT_MIN
# define INT_MIN (-INT_MAX-1)
# undef INT_MAX
# define INT_MAX __INT_MAX__
/* Maximum value an `unsigned int' can hold. (Minimum is 0). */
# undef UINT_MAX
# define UINT_MAX (INT_MAX * 2U + 1)
/* Minimum and maximum values a `signed long int' can hold.
(Same as `int'). */
# ifndef __LONG_MAX__
# if defined (__alpha__) || (defined (__sparc__) && defined(__arch64__)) || defined (__sparcv9)
# define __LONG_MAX__ 9223372036854775807L
# else
# define __LONG_MAX__ 2147483647L
# endif /* __alpha__ || sparc64 */
# endif
# undef LONG_MIN
# define LONG_MIN (-LONG_MAX-1)
# undef LONG_MAX
# define LONG_MAX __LONG_MAX__
/* Maximum value an `unsigned long int' can hold. (Minimum is 0). */
# undef ULONG_MAX
# define ULONG_MAX (LONG_MAX * 2UL + 1)
# ifndef __LONG_LONG_MAX__
# define __LONG_LONG_MAX__ 9223372036854775807LL
# endif
# if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* Minimum and maximum values a `signed long long int' can hold. */
# undef LLONG_MIN
# define LLONG_MIN (-LLONG_MAX-1)
# undef LLONG_MAX
# define LLONG_MAX __LONG_LONG_MAX__
/* Maximum value an `unsigned long long int' can hold. (Minimum is 0). */
# undef ULLONG_MAX
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
# endif
# if defined (__GNU_LIBRARY__) ? defined (__USE_GNU) : !defined (__STRICT_ANSI__)
/* Minimum and maximum values a `signed long long int' can hold. */
# undef LONG_LONG_MIN
# define LONG_LONG_MIN (-LONG_LONG_MAX-1)
# undef LONG_LONG_MAX
# define LONG_LONG_MAX __LONG_LONG_MAX__
/* Maximum value an `unsigned long long int' can hold. (Minimum is 0). */
# undef ULONG_LONG_MAX
# define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1)
# endif
# endif /* _LIMITS_H */
# endif /* GCC 2. */
#endif /* !_LIBC_LIMITS_H_ */
#if defined __GNUC__ && !defined _GCC_LIMITS_H_
/* `_GCC_LIMITS_H_' is what GCC's file defines. */
# include_next <limits.h>
#endif /* __GNUC__ && !_GCC_LIMITS_H_ */
#ifndef _POSIX2_RE_DUP_MAX
/* The maximum number of repeated occurrences of a regular expression
* permitted when using the interval notation `\{M,N\}'. */
#define _POSIX2_RE_DUP_MAX 255
#endif /* _POSIX2_RE_DUP_MAX */
#ifndef ARG_MAX
#define ARG_MAX 4096
#endif
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif

65
programs/develop/libraries/newlib/include/locale.h Normal file
View File

@ -0,0 +1,65 @@
/*
locale.h
Values appropriate for the formatting of monetary and other
numberic quantities.
*/
#ifndef _LOCALE_H_
#define _LOCALE_H_
#include "_ansi.h"
#ifndef NULL
#define NULL 0
#endif
#define LC_ALL 0
#define LC_COLLATE 1
#define LC_CTYPE 2
#define LC_MONETARY 3
#define LC_NUMERIC 4
#define LC_TIME 5
#define LC_MESSAGES 6
_BEGIN_STD_C
struct lconv
{
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
char int_n_cs_precedes;
char int_n_sep_by_space;
char int_n_sign_posn;
char int_p_cs_precedes;
char int_p_sep_by_space;
char int_p_sign_posn;
};
#ifndef _REENT_ONLY
char *_EXFUN(setlocale,(int category, const char *locale));
struct lconv *_EXFUN(localeconv,(void));
#endif
struct _reent;
char *_EXFUN(_setlocale_r,(struct _reent *, int category, const char *locale));
struct lconv *_EXFUN(_localeconv_r,(struct _reent *));
_END_STD_C
#endif /* _LOCALE_H_ */

121
programs/develop/libraries/newlib/include/machine/_default_types.h Normal file
View File

@ -0,0 +1,121 @@
/*
* $Id: _default_types.h,v 1.2 2008/06/11 22:14:54 jjohnstn Exp $
*/
#ifndef _MACHINE__DEFAULT_TYPES_H
#define _MACHINE__DEFAULT_TYPES_H
#ifdef __cplusplus
extern "C" {
#endif
/*
* Guess on types by examining *_MIN / *_MAX defines.
*/
#if defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ >= 3 ) \
&& defined(__GNUC_MINOR__) && (__GNUC_MINOR__ > 2 ))
/* GCC >= 3.3.0 has __<val>__ implicitly defined. */
#define __EXP(x) __##x##__
#else
/* Fall back to POSIX versions from <limits.h> */
#define __EXP(x) x
#include <limits.h>
#endif
#if __EXP(SCHAR_MAX) == 0x7f
typedef signed char __int8_t ;
typedef unsigned char __uint8_t ;
#define ___int8_t_defined 1
#endif
#if __EXP(INT_MAX) == 0x7fff
typedef signed int __int16_t;
typedef unsigned int __uint16_t;
#define ___int16_t_defined 1
#elif __EXP(SHRT_MAX) == 0x7fff
typedef signed short __int16_t;
typedef unsigned short __uint16_t;
#define ___int16_t_defined 1
#elif __EXP(SCHAR_MAX) == 0x7fff
typedef signed char __int16_t;
typedef unsigned char __uint16_t;
#define ___int16_t_defined 1
#endif
#if ___int16_t_defined
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
#define ___int_least16_t_defined 1
#if !___int8_t_defined
typedef __int16_t __int_least8_t;
typedef __uint16_t __uint_least8_t;
#define ___int_least8_t_defined 1
#endif
#endif
#if __EXP(INT_MAX) == 0x7fffffffL
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
#define ___int32_t_defined 1
#elif __EXP(LONG_MAX) == 0x7fffffffL
typedef signed long __int32_t;
typedef unsigned long __uint32_t;
#define ___int32_t_defined 1
#elif __EXP(SHRT_MAX) == 0x7fffffffL
typedef signed short __int32_t;
typedef unsigned short __uint32_t;
#define ___int32_t_defined 1
#elif __EXP(SCHAR_MAX) == 0x7fffffffL
typedef signed char __int32_t;
typedef unsigned char __uint32_t;
#define ___int32_t_defined 1
#endif
#if ___int32_t_defined
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
#define ___int_least32_t_defined 1
#if !___int8_t_defined
typedef __int32_t __int_least8_t;
typedef __uint32_t __uint_least8_t;
#define ___int_least8_t_defined 1
#endif
#if !___int16_t_defined
typedef __int32_t __int_least16_t;
typedef __uint32_t __uint_least16_t;
#define ___int_least16_t_defined 1
#endif
#endif
#if __EXP(LONG_MAX) > 0x7fffffff
typedef signed long __int64_t;
typedef unsigned long __uint64_t;
#define ___int64_t_defined 1
/* GCC has __LONG_LONG_MAX__ */
#elif defined(__LONG_LONG_MAX__) && (__LONG_LONG_MAX__ > 0x7fffffff)
typedef signed long long __int64_t;
typedef unsigned long long __uint64_t;
#define ___int64_t_defined 1
/* POSIX mandates LLONG_MAX in <limits.h> */
#elif defined(LLONG_MAX) && (LLONG_MAX > 0x7fffffff)
typedef signed long long __int64_t;
typedef unsigned long long __uint64_t;
#define ___int64_t_defined 1
#elif __EXP(INT_MAX) > 0x7fffffff
typedef signed int __int64_t;
typedef unsigned int __uint64_t;
#define ___int64_t_defined 1
#endif
#undef __EXP
#ifdef __cplusplus
}
#endif
#endif /* _MACHINE__DEFAULT_TYPES_H */

8
programs/develop/libraries/newlib/include/machine/_types.h Normal file
View File

@ -0,0 +1,8 @@
/*
* $Id: _types.h,v 1.3 2007/09/07 21:16:25 jjohnstn Exp $
*/
#ifndef _MACHINE__TYPES_H
#define _MACHINE__TYPES_H
#include <machine/_default_types.h>
#endif

1
programs/develop/libraries/newlib/include/machine/ansi.h Normal file
View File

@ -0,0 +1 @@
/* dummy header file to support BSD compiler */

20
programs/develop/libraries/newlib/include/machine/endian.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef __MACHINE_ENDIAN_H__
#include <sys/config.h>
#ifndef BIG_ENDIAN
#define BIG_ENDIAN 4321
#endif
#ifndef LITTLE_ENDIAN
#define LITTLE_ENDIAN 1234
#endif
#ifndef BYTE_ORDER
#if defined(__IEEE_LITTLE_ENDIAN) || defined(__IEEE_BYTES_LITTLE_ENDIAN)
#define BYTE_ORDER LITTLE_ENDIAN
#else
#define BYTE_ORDER BIG_ENDIAN
#endif
#endif
#endif /* __MACHINE_ENDIAN_H__ */

100
programs/develop/libraries/newlib/include/machine/fastmath.h Normal file
View File

@ -0,0 +1,100 @@
#ifdef __sysvnecv70_target
double EXFUN(fast_sin,(double));
double EXFUN(fast_cos,(double));
double EXFUN(fast_tan,(double));
double EXFUN(fast_asin,(double));
double EXFUN(fast_acos,(double));
double EXFUN(fast_atan,(double));
double EXFUN(fast_sinh,(double));
double EXFUN(fast_cosh,(double));
double EXFUN(fast_tanh,(double));
double EXFUN(fast_asinh,(double));
double EXFUN(fast_acosh,(double));
double EXFUN(fast_atanh,(double));
double EXFUN(fast_abs,(double));
double EXFUN(fast_sqrt,(double));
double EXFUN(fast_exp2,(double));
double EXFUN(fast_exp10,(double));
double EXFUN(fast_expe,(double));
double EXFUN(fast_log10,(double));
double EXFUN(fast_log2,(double));
double EXFUN(fast_loge,(double));
#define sin(x) fast_sin(x)
#define cos(x) fast_cos(x)
#define tan(x) fast_tan(x)
#define asin(x) fast_asin(x)
#define acos(x) fast_acos(x)
#define atan(x) fast_atan(x)
#define sinh(x) fast_sinh(x)
#define cosh(x) fast_cosh(x)
#define tanh(x) fast_tanh(x)
#define asinh(x) fast_asinh(x)
#define acosh(x) fast_acosh(x)
#define atanh(x) fast_atanh(x)
#define abs(x) fast_abs(x)
#define sqrt(x) fast_sqrt(x)
#define exp2(x) fast_exp2(x)
#define exp10(x) fast_exp10(x)
#define expe(x) fast_expe(x)
#define log10(x) fast_log10(x)
#define log2(x) fast_log2(x)
#define loge(x) fast_loge(x)
#ifdef _HAVE_STDC
/* These functions are in assembler, they really do take floats. This
can only be used with a real ANSI compiler */
float EXFUN(fast_sinf,(float));
float EXFUN(fast_cosf,(float));
float EXFUN(fast_tanf,(float));
float EXFUN(fast_asinf,(float));
float EXFUN(fast_acosf,(float));
float EXFUN(fast_atanf,(float));
float EXFUN(fast_sinhf,(float));
float EXFUN(fast_coshf,(float));
float EXFUN(fast_tanhf,(float));
float EXFUN(fast_asinhf,(float));
float EXFUN(fast_acoshf,(float));
float EXFUN(fast_atanhf,(float));
float EXFUN(fast_absf,(float));
float EXFUN(fast_sqrtf,(float));
float EXFUN(fast_exp2f,(float));
float EXFUN(fast_exp10f,(float));
float EXFUN(fast_expef,(float));
float EXFUN(fast_log10f,(float));
float EXFUN(fast_log2f,(float));
float EXFUN(fast_logef,(float));
#define sinf(x) fast_sinf(x)
#define cosf(x) fast_cosf(x)
#define tanf(x) fast_tanf(x)
#define asinf(x) fast_asinf(x)
#define acosf(x) fast_acosf(x)
#define atanf(x) fast_atanf(x)
#define sinhf(x) fast_sinhf(x)
#define coshf(x) fast_coshf(x)
#define tanhf(x) fast_tanhf(x)
#define asinhf(x) fast_asinhf(x)
#define acoshf(x) fast_acoshf(x)
#define atanhf(x) fast_atanhf(x)
#define absf(x) fast_absf(x)
#define sqrtf(x) fast_sqrtf(x)
#define exp2f(x) fast_exp2f(x)
#define exp10f(x) fast_exp10f(x)
#define expef(x) fast_expef(x)
#define log10f(x) fast_log10f(x)
#define log2f(x) fast_log2f(x)
#define logef(x) fast_logef(x)
#endif
/* Override the functions defined in math.h */
#endif /* __sysvnecv70_target */

371
programs/develop/libraries/newlib/include/machine/ieeefp.h Normal file
View File

@ -0,0 +1,371 @@
#ifndef __IEEE_BIG_ENDIAN
#ifndef __IEEE_LITTLE_ENDIAN
/* This file can define macros to choose variations of the IEEE float
format:
_FLT_LARGEST_EXPONENT_IS_NORMAL
Defined if the float format uses the largest exponent for finite
numbers rather than NaN and infinity representations. Such a
format cannot represent NaNs or infinities at all, but it's FLT_MAX
is twice the IEEE value.
_FLT_NO_DENORMALS
Defined if the float format does not support IEEE denormals. Every
float with a zero exponent is taken to be a zero representation.
??? At the moment, there are no equivalent macros above for doubles and
the macros are not fully supported by --enable-newlib-hw-fp.
__IEEE_BIG_ENDIAN
Defined if the float format is big endian. This is mutually exclusive
with __IEEE_LITTLE_ENDIAN.
__IEEE_LITTLE_ENDIAN
Defined if the float format is little endian. This is mutually exclusive
with __IEEE_BIG_ENDIAN.
Note that one of __IEEE_BIG_ENDIAN or __IEEE_LITTLE_ENDIAN must be specified for a
platform or error will occur.
__IEEE_BYTES_LITTLE_ENDIAN
This flag is used in conjunction with __IEEE_BIG_ENDIAN to describe a situation
whereby multiple words of an IEEE floating point are in big endian order, but the
words themselves are little endian with respect to the bytes.
_DOUBLE_IS_32BITS
This is used on platforms that support double by using the 32-bit IEEE
float type.
_FLOAT_ARG
This represents what type a float arg is passed as. It is used when the type is
not promoted to double.
*/
#if (defined(__arm__) || defined(__thumb__)) && !defined(__MAVERICK__)
/* ARM traditionally used big-endian words; and within those words the
byte ordering was big or little endian depending upon the target.
Modern floating-point formats are naturally ordered; in this case
__VFP_FP__ will be defined, even if soft-float. */
#ifdef __VFP_FP__
# ifdef __ARMEL__
# define __IEEE_LITTLE_ENDIAN
# else
# define __IEEE_BIG_ENDIAN
# endif
#else
# define __IEEE_BIG_ENDIAN
# ifdef __ARMEL__
# define __IEEE_BYTES_LITTLE_ENDIAN
# endif
#endif
#endif
#ifdef __hppa__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __SPU__
#define __IEEE_BIG_ENDIAN
#define isfinite(__y) \
(__extension__ ({int __cy; \
(sizeof (__y) == sizeof (float)) ? (1) : \
(__cy = fpclassify(__y)) != FP_INFINITE && __cy != FP_NAN;}))
#define isinf(__x) ((sizeof (__x) == sizeof (float)) ? (0) : __isinfd(__x))
#define isnan(__x) ((sizeof (__x) == sizeof (float)) ? (0) : __isnand(__x))
/*
* Macros for use in ieeefp.h. We can't just define the real ones here
* (like those above) as we have name space issues when this is *not*
* included via generic the ieeefp.h.
*/
#define __ieeefp_isnanf(x) 0
#define __ieeefp_isinff(x) 0
#define __ieeefp_finitef(x) 1
#endif
#ifdef __sparc__
#ifdef __LITTLE_ENDIAN_DATA__
#define __IEEE_LITTLE_ENDIAN
#else
#define __IEEE_BIG_ENDIAN
#endif
#endif
#if defined(__m68k__) || defined(__mc68000__)
#define __IEEE_BIG_ENDIAN
#endif
#if defined(__mc68hc11__) || defined(__mc68hc12__) || defined(__mc68hc1x__)
#define __IEEE_BIG_ENDIAN
#ifdef __HAVE_SHORT_DOUBLE__
# define _DOUBLE_IS_32BITS
#endif
#endif
#if defined (__H8300__) || defined (__H8300H__) || defined (__H8300S__) || defined (__H8500__) || defined (__H8300SX__)
#define __IEEE_BIG_ENDIAN
#define _FLOAT_ARG float
#define _DOUBLE_IS_32BITS
#endif
#if defined (__xc16x__) || defined (__xc16xL__) || defined (__xc16xS__)
#define __IEEE_LITTLE_ENDIAN
#define _FLOAT_ARG float
#define _DOUBLE_IS_32BITS
#endif
#ifdef __sh__
#ifdef __LITTLE_ENDIAN__
#define __IEEE_LITTLE_ENDIAN
#else
#define __IEEE_BIG_ENDIAN
#endif
#if defined(__SH2E__) || defined(__SH3E__) || defined(__SH4_SINGLE_ONLY__) || defined(__SH2A_SINGLE_ONLY__)
#define _DOUBLE_IS_32BITS
#endif
#endif
#ifdef _AM29K
#define __IEEE_BIG_ENDIAN
#endif
#ifdef _WIN32
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __i386__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __i960__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __lm32__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __M32R__
#define __IEEE_BIG_ENDIAN
#endif
#if defined(_C4x) || defined(_C3x)
#define __IEEE_BIG_ENDIAN
#define _DOUBLE_IS_32BITS
#endif
#ifdef __TMS320C6X__
#ifdef _BIG_ENDIAN
#define __IEEE_BIG_ENDIAN
#else
#define __IEEE_LITTLE_ENDIAN
#endif
#endif
#ifdef __TIC80__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __MIPSEL__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __MIPSEB__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __MMIX__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __D30V__
#define __IEEE_BIG_ENDIAN
#endif
/* necv70 was __IEEE_LITTLE_ENDIAN. */
#ifdef __W65__
#define __IEEE_LITTLE_ENDIAN
#define _DOUBLE_IS_32BITS
#endif
#if defined(__Z8001__) || defined(__Z8002__)
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __m88k__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __mn10300__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __mn10200__
#define __IEEE_LITTLE_ENDIAN
#define _DOUBLE_IS_32BITS
#endif
#ifdef __v800
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __v850
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __D10V__
#define __IEEE_BIG_ENDIAN
#if __DOUBLE__ == 32
#define _DOUBLE_IS_32BITS
#endif
#endif
#ifdef __PPC__
#if (defined(_BIG_ENDIAN) && _BIG_ENDIAN) || (defined(_AIX) && _AIX)
#define __IEEE_BIG_ENDIAN
#else
#if (defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN) || (defined(__sun__) && __sun__) || (defined(_WIN32) && _WIN32)
#define __IEEE_LITTLE_ENDIAN
#endif
#endif
#endif
#ifdef __xstormy16__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __arc__
#ifdef __big_endian__
#define __IEEE_BIG_ENDIAN
#else
#define __IEEE_LITTLE_ENDIAN
#endif
#endif
#ifdef __CRX__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __fr30__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __mcore__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __mt__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __frv__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __moxie__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __ia64__
#ifdef __BIG_ENDIAN__
#define __IEEE_BIG_ENDIAN
#else
#define __IEEE_LITTLE_ENDIAN
#endif
#endif
#ifdef __AVR__
#define __IEEE_LITTLE_ENDIAN
#define _DOUBLE_IS_32BITS
#endif
#if defined(__or32__) || defined(__or1k__) || defined(__or16__)
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __IP2K__
#define __IEEE_BIG_ENDIAN
#define __SMALL_BITFIELDS
#define _DOUBLE_IS_32BITS
#endif
#ifdef __iq2000__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __MAVERICK__
#ifdef __ARMEL__
# define __IEEE_LITTLE_ENDIAN
#else /* must be __ARMEB__ */
# define __IEEE_BIG_ENDIAN
#endif /* __ARMEL__ */
#endif /* __MAVERICK__ */
#ifdef __m32c__
#define __IEEE_LITTLE_ENDIAN
#define __SMALL_BITFIELDS
#endif
#ifdef __CRIS__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __BFIN__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __x86_64__
#define __IEEE_LITTLE_ENDIAN
#endif
#ifdef __mep__
#ifdef __LITTLE_ENDIAN__
#define __IEEE_LITTLE_ENDIAN
#else
#define __IEEE_BIG_ENDIAN
#endif
#endif
#ifdef __MICROBLAZE__
#define __IEEE_BIG_ENDIAN
#endif
#ifdef __RX__
#ifdef __RX_BIG_ENDIAN__
#define __IEEE_BIG_ENDIAN
#else
#define __IEEE_LITTLE_ENDIAN
#endif
#ifndef __RX_64BIT_DOUBLES__
#define _DOUBLE_IS_32BITS
#endif
#ifdef __RX_16BIT_INTS__
#define __SMALL_BITFIELDS
#endif
#endif
#ifndef __IEEE_BIG_ENDIAN
#ifndef __IEEE_LITTLE_ENDIAN
#error Endianess not declared!!
#endif /* not __IEEE_LITTLE_ENDIAN */
#endif /* not __IEEE_BIG_ENDIAN */
#endif /* not __IEEE_LITTLE_ENDIAN */
#endif /* not __IEEE_BIG_ENDIAN */

8
programs/develop/libraries/newlib/include/machine/malloc.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef _MACHMALLOC_H_
#define _MACHMALLOC_H_
/* place holder so platforms may add malloc.h extensions */
#endif /* _MACHMALLOC_H_ */

1
programs/develop/libraries/newlib/include/machine/param.h Normal file
View File

@ -0,0 +1 @@
/* Place holder for machine-specific param.h. */

43
programs/develop/libraries/newlib/include/machine/setjmp-dj.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (C) 1991 DJ Delorie
* All rights reserved.
*
* Redistribution and use in source and binary forms is permitted
* provided that the above copyright notice and following paragraph are
* duplicated in all such forms.
*
* This file is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
/* Modified to use SETJMP_DJ_H rather than SETJMP_H to avoid
conflicting with setjmp.h. Ian Taylor, Cygnus support, April,
1993. */
#ifndef _SETJMP_DJ_H_
#define _SETJMP_DJ_H_
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
unsigned long eax;
unsigned long ebx;
unsigned long ecx;
unsigned long edx;
unsigned long esi;
unsigned long edi;
unsigned long ebp;
unsigned long esp;
unsigned long eip;
} jmp_buf[1];
extern int setjmp(jmp_buf);
extern void longjmp(jmp_buf, int);
#ifdef __cplusplus
}
#endif
#endif

349
programs/develop/libraries/newlib/include/machine/setjmp.h Normal file
View File

@ -0,0 +1,349 @@
_BEGIN_STD_C
#if defined(__arm__) || defined(__thumb__)
/*
* All callee preserved registers:
* v1 - v7, fp, ip, sp, lr, f4, f5, f6, f7
*/
#define _JBLEN 23
#endif
#if defined(__AVR__)
#define _JBLEN 24
#endif
#ifdef __sparc__
/*
* onsstack,sigmask,sp,pc,npc,psr,g1,o0,wbcnt (sigcontext).
* All else recovered by under/over(flow) handling.
*/
#define _JBLEN 13
#endif
#ifdef __BFIN__
#define _JBLEN 40
#endif
/* necv70 was 9 as well. */
#if defined(__m68k__) || defined(__mc68000__)
/*
* onsstack,sigmask,sp,pc,psl,d2-d7,a2-a6,
* fp2-fp7 for 68881.
* All else recovered by under/over(flow) handling.
*/
#define _JBLEN 34
#endif
#if defined(__mc68hc11__) || defined(__mc68hc12__) || defined(__mc68hc1x__)
/*
* D, X, Y are not saved.
* Only take into account the pseudo soft registers (max 32).
*/
#define _JBLEN 32
#endif
#if defined(__Z8001__) || defined(__Z8002__)
/* 16 regs + pc */
#define _JBLEN 20
#endif
#ifdef _AM29K
/*
* onsstack,sigmask,sp,pc,npc,psr,g1,o0,wbcnt (sigcontext).
* All else recovered by under/over(flow) handling.
*/
#define _JBLEN 9
#endif
#if defined(__CYGWIN__) && !defined (_JBLEN)
#define _JBLEN (13 * 4)
#elif defined (__i386__)
#if defined(__unix__) || defined(__rtems__)
# define _JBLEN 9
#else
#include "setjmp-dj.h"
#endif
#endif
#ifdef __x86_64__
#define _JBTYPE long long
#define _JBLEN 8
#endif
#ifdef __i960__
#define _JBLEN 35
#endif
#ifdef __M32R__
/* Only 8 words are currently needed. 10 gives us some slop if we need
to expand. */
#define _JBLEN 10
#endif
#ifdef __mips__
#ifdef __mips64
#define _JBTYPE long long
#endif
#ifdef __mips_soft_float
#define _JBLEN 11
#else
#define _JBLEN 23
#endif
#endif
#ifdef __m88000__
#define _JBLEN 21
#endif
#ifdef __H8300__
#define _JBLEN 5
#define _JBTYPE int
#endif
#ifdef __H8300H__
/* same as H8/300 but registers are twice as big */
#define _JBLEN 5
#define _JBTYPE long
#endif
#if defined (__H8300S__) || defined (__H8300SX__)
/* same as H8/300 but registers are twice as big */
#define _JBLEN 5
#define _JBTYPE long
#endif
#ifdef __H8500__
#define _JBLEN 4
#endif
#ifdef __sh__
#if __SH5__
#define _JBLEN 50
#define _JBTYPE long long
#else
#define _JBLEN 20
#endif /* __SH5__ */
#endif
#ifdef __v800
#define _JBLEN 28
#endif
#ifdef __PPC__
#ifdef __ALTIVEC__
#define _JBLEN 64
#else
#define _JBLEN 32
#endif
#define _JBTYPE double
#endif
#ifdef __MICROBLAZE__
#define _JBLEN 20
#define _JBTYPE unsigned int
#endif
#ifdef __hppa__
/* %r30, %r2-%r18, %r27, pad, %fr12-%fr15.
Note space exists for the FP registers, but they are not
saved. */
#define _JBLEN 28
#endif
#if defined(__mn10300__) || defined(__mn10200__)
#ifdef __AM33_2__
#define _JBLEN 26
#else
/* A guess */
#define _JBLEN 10
#endif
#endif
#ifdef __v850
/* I think our setjmp is saving 15 regs at the moment. Gives us one word
slop if we need to expand. */
#define _JBLEN 16
#endif
#if defined(_C4x)
#define _JBLEN 10
#endif
#if defined(_C3x)
#define _JBLEN 9
#endif
#ifdef __TMS320C6X__
#define _JBLEN 13
#endif
#ifdef __TIC80__
#define _JBLEN 13
#endif
#ifdef __D10V__
#define _JBLEN 8
#endif
#ifdef __D30V__
#define _JBLEN ((64 /* GPR */ + (2*2) /* ACs */ + 18 /* CRs */) / 2)
#define _JBTYPE double
#endif
#ifdef __frv__
#define _JBLEN (68/2) /* room for 68 32-bit regs */
#define _JBTYPE double
#endif
#ifdef __moxie__
#define _JBLEN 16
#endif
#ifdef __CRX__
#define _JBLEN 9
#endif
#ifdef __fr30__
#define _JBLEN 10
#endif
#ifdef __iq2000__
#define _JBLEN 32
#endif
#ifdef __mcore__
#define _JBLEN 16
#endif
#ifdef __MMIX__
/* Using a layout compatible with GCC's built-in. */
#define _JBLEN 5
#define _JBTYPE unsigned long
#endif
#ifdef __mt__
#define _JBLEN 16
#endif
#ifdef __SPU__
#define _JBLEN 50
#define _JBTYPE __vector signed int
#endif
#ifdef __xstormy16__
/* 4 GPRs plus SP plus PC. */
#define _JBLEN 8
#endif
#ifdef __mep__
/* 16 GPRs, pc, hi, lo */
#define _JBLEN 19
#endif
#ifdef __CRIS__
#define _JBLEN 18
#endif
#ifdef __lm32__
#define _JBLEN 19
#endif
#ifdef __m32c__
#if defined(__r8c_cpu__) || defined(__m16c_cpu__)
#define _JBLEN (22/2)
#else
#define _JBLEN (34/2)
#endif
#define _JBTYPE unsigned short
#endif /* __m32c__ */
#ifdef __RX__
#define _JBLEN 0x44
#endif
#ifdef _JBLEN
#ifdef _JBTYPE
typedef _JBTYPE jmp_buf[_JBLEN];
#else
typedef int jmp_buf[_JBLEN];
#endif
#endif
_END_STD_C
#if defined(__CYGWIN__) || defined(__rtems__)
#include <signal.h>
#ifdef __cplusplus
extern "C" {
#endif
/* POSIX sigsetjmp/siglongjmp macros */
#ifdef _JBTYPE
typedef _JBTYPE sigjmp_buf[_JBLEN+1+(sizeof (sigset_t)/sizeof (_JBTYPE))];
#else
typedef int sigjmp_buf[_JBLEN+1+(sizeof (sigset_t)/sizeof (int))];
#endif
#define _SAVEMASK _JBLEN
#define _SIGMASK (_JBLEN+1)
#ifdef __CYGWIN__
# define _CYGWIN_WORKING_SIGSETJMP
#endif
#ifdef _POSIX_THREADS
#define __SIGMASK_FUNC pthread_sigmask
#else
#define __SIGMASK_FUNC sigprocmask
#endif
#if defined(__GNUC__)
#define sigsetjmp(env, savemask) \
__extension__ \
({ \
sigjmp_buf *_sjbuf = &(env); \
((*_sjbuf)[_SAVEMASK] = savemask,\
__SIGMASK_FUNC (SIG_SETMASK, 0, (sigset_t *)((*_sjbuf) + _SIGMASK)),\
setjmp (*_sjbuf)); \
})
#define siglongjmp(env, val) \
__extension__ \
({ \
sigjmp_buf *_sjbuf = &(env); \
((((*_sjbuf)[_SAVEMASK]) ? \
__SIGMASK_FUNC (SIG_SETMASK, (sigset_t *)((*_sjbuf) + _SIGMASK), 0)\
: 0), \
longjmp (*_sjbuf, val)); \
})
#else /* !__GNUC__ */
#define sigsetjmp(env, savemask) ((env)[_SAVEMASK] = savemask,\
__SIGMASK_FUNC (SIG_SETMASK, 0, (sigset_t *) ((env) + _SIGMASK)),\
setjmp (env))
#define siglongjmp(env, val) ((((env)[_SAVEMASK])?\
__SIGMASK_FUNC (SIG_SETMASK, (sigset_t *) ((env) + _SIGMASK), 0):0),\
longjmp (env, val))
#endif
/* POSIX _setjmp/_longjmp, maintained for XSI compatibility. These
are equivalent to sigsetjmp/siglongjmp when not saving the signal mask.
New applications should use sigsetjmp/siglongjmp instead. */
#ifdef __CYGWIN__
extern void _longjmp(jmp_buf, int);
extern int _setjmp(jmp_buf);
#else
#define _setjmp(env) sigsetjmp ((env), 0)
#define _longjmp(env, val) siglongjmp ((env), (val))
#endif
#ifdef __cplusplus
}
#endif
#endif /* __CYGWIN__ or __rtems__ */

8
programs/develop/libraries/newlib/include/machine/stdlib.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef _MACHSTDLIB_H_
#define _MACHSTDLIB_H_
/* place holder so platforms may add stdlib.h extensions */
#endif /* _MACHSTDLIB_H_ */

1
programs/develop/libraries/newlib/include/machine/termios.h Normal file
View File

@ -0,0 +1 @@
#define __MAX_BAUD B4000000

19
programs/develop/libraries/newlib/include/machine/time.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef _MACHTIME_H_
#define _MACHTIME_H_
#if defined(__rtems__)
#define _CLOCKS_PER_SEC_ sysconf(_SC_CLK_TCK)
#else /* !__rtems__ */
#if defined(__arm__) || defined(__thumb__)
#define _CLOCKS_PER_SEC_ 100
#endif
#endif /* !__rtems__ */
#ifdef __SPU__
#include <sys/types.h>
int nanosleep (const struct timespec *, struct timespec *);
#endif
#endif /* _MACHTIME_H_ */

30
programs/develop/libraries/newlib/include/machine/types.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef _MACHTYPES_H_
#define _MACHTYPES_H_
/*
* The following section is RTEMS specific and is needed to more
* closely match the types defined in the BSD machine/types.h.
* This is needed to let the RTEMS/BSD TCP/IP stack compile.
*/
#if defined(__rtems__)
#include <machine/_types.h>
#endif
#define _CLOCK_T_ unsigned long /* clock() */
#define _TIME_T_ long /* time() */
#define _CLOCKID_T_ unsigned long
#define _TIMER_T_ unsigned long
#ifndef _HAVE_SYSTYPES
typedef long int __off_t;
typedef int __pid_t;
#ifdef __GNUC__
__extension__ typedef long long int __loff_t;
#else
typedef long int __loff_t;
#endif
#endif
#endif /* _MACHTYPES_H_ */

169
programs/develop/libraries/newlib/include/malloc.h Normal file
View File

@ -0,0 +1,169 @@
/* malloc.h -- header file for memory routines. */
#ifndef _INCLUDE_MALLOC_H_
#define _INCLUDE_MALLOC_H_
#include <_ansi.h>
#include <sys/reent.h>
#define __need_size_t
#include <stddef.h>
/* include any machine-specific extensions */
#include <machine/malloc.h>
#ifdef __cplusplus
extern "C" {
#endif
/* This version of struct mallinfo must match the one in
libc/stdlib/mallocr.c. */
struct mallinfo {
int arena; /* total space allocated from system */
int ordblks; /* number of non-inuse chunks */
int smblks; /* unused -- always zero */
int hblks; /* number of mmapped regions */
int hblkhd; /* total space in mmapped regions */
int usmblks; /* unused -- always zero */
int fsmblks; /* unused -- always zero */
int uordblks; /* total allocated space */
int fordblks; /* total non-inuse space */
int keepcost; /* top-most, releasable (via malloc_trim) space */
};
/* The routines. */
extern _PTR malloc _PARAMS ((size_t));
#ifdef __CYGWIN__
#undef _malloc_r
#define _malloc_r(r, s) malloc (s)
#else
extern _PTR _malloc_r _PARAMS ((struct _reent *, size_t));
#endif
extern _VOID free _PARAMS ((_PTR));
#ifdef __CYGWIN__
#undef _free_r
#define _free_r(r, p) free (p)
#else
extern _VOID _free_r _PARAMS ((struct _reent *, _PTR));
#endif
extern _PTR realloc _PARAMS ((_PTR, size_t));
#ifdef __CYGWIN__
#undef _realloc_r
#define _realloc_r(r, p, s) realloc (p, s)
#else
extern _PTR _realloc_r _PARAMS ((struct _reent *, _PTR, size_t));
#endif
extern _PTR calloc _PARAMS ((size_t, size_t));
#ifdef __CYGWIN__
#undef _calloc_r
#define _calloc_r(r, s1, s2) calloc (s1, s2);
#else
extern _PTR _calloc_r _PARAMS ((struct _reent *, size_t, size_t));
#endif
extern _PTR memalign _PARAMS ((size_t, size_t));
#ifdef __CYGWIN__
#undef _memalign_r
#define _memalign_r(r, s1, s2) memalign (s1, s2);
#else
extern _PTR _memalign_r _PARAMS ((struct _reent *, size_t, size_t));
#endif
extern struct mallinfo mallinfo _PARAMS ((void));
#ifdef __CYGWIN__
#undef _mallinfo_r
#define _mallinfo_r(r) mallinfo ()
#else
extern struct mallinfo _mallinfo_r _PARAMS ((struct _reent *));
#endif
extern void malloc_stats _PARAMS ((void));
#ifdef __CYGWIN__
#undef _malloc_stats_r
#define _malloc_stats_r(r) malloc_stats ()
#else
extern void _malloc_stats_r _PARAMS ((struct _reent *));
#endif
extern int mallopt _PARAMS ((int, int));
#ifdef __CYGWIN__
#undef _mallopt_r
#define _mallopt_r(i1, i2) mallopt (i1, i2)
#else
extern int _mallopt_r _PARAMS ((struct _reent *, int, int));
#endif
extern size_t malloc_usable_size _PARAMS ((_PTR));
#ifdef __CYGWIN__
#undef _malloc_usable_size_r
#define _malloc_usable_size_r(r, p) malloc_usable_size (p)
#else
extern size_t _malloc_usable_size_r _PARAMS ((struct _reent *, _PTR));
#endif
/* These aren't too useful on an embedded system, but we define them
anyhow. */
extern _PTR valloc _PARAMS ((size_t));
#ifdef __CYGWIN__
#undef _valloc_r
#define _valloc_r(r, s) valloc (s)
#else
extern _PTR _valloc_r _PARAMS ((struct _reent *, size_t));
#endif
extern _PTR pvalloc _PARAMS ((size_t));
#ifdef __CYGWIN__
#undef _pvalloc_r
#define _pvalloc_r(r, s) pvalloc (s)
#else
extern _PTR _pvalloc_r _PARAMS ((struct _reent *, size_t));
#endif
extern int malloc_trim _PARAMS ((size_t));
#ifdef __CYGWIN__
#undef _malloc_trim_r
#define _malloc_trim_r(r, s) malloc_trim (s)
#else
extern int _malloc_trim_r _PARAMS ((struct _reent *, size_t));
#endif
/* A compatibility routine for an earlier version of the allocator. */
extern _VOID mstats _PARAMS ((char *));
#ifdef __CYGWIN__
#undef _mstats_r
#define _mstats_r(r, p) mstats (p)
#else
extern _VOID _mstats_r _PARAMS ((struct _reent *, char *));
#endif
/* SVID2/XPG mallopt options */
#define M_MXFAST 1 /* UNUSED in this malloc */
#define M_NLBLKS 2 /* UNUSED in this malloc */
#define M_GRAIN 3 /* UNUSED in this malloc */
#define M_KEEP 4 /* UNUSED in this malloc */
/* mallopt options that actually do something */
#define M_TRIM_THRESHOLD -1
#define M_TOP_PAD -2
#define M_MMAP_THRESHOLD -3
#define M_MMAP_MAX -4
#ifndef __CYGWIN__
/* Some systems provide this, so do too for compatibility. */
extern void cfree _PARAMS ((_PTR));
#endif /* __CYGWIN__ */
#ifdef __cplusplus
}
#endif
#endif /* _INCLUDE_MALLOC_H_ */

580
programs/develop/libraries/newlib/include/math.h Normal file
View File

@ -0,0 +1,580 @@
#ifndef _MATH_H_
#define _MATH_H_
#include <sys/reent.h>
#include <machine/ieeefp.h>
#include "_ansi.h"
_BEGIN_STD_C
/* __dmath, __fmath, and __ldmath are only here for backwards compatibility
* in case any code used them. They are no longer used by Newlib, itself,
* other than legacy. */
union __dmath
{
double d;
__ULong i[2];
};
union __fmath
{
float f;
__ULong i[1];
};
#if defined(_HAVE_LONG_DOUBLE)
union __ldmath
{
long double ld;
__ULong i[4];
};
#endif
/* Natural log of 2 */
#define _M_LOG2_E 0.693147180559945309417
#if defined(__GNUC__) && \
( (__GNUC__ >= 4) || \
( (__GNUC__ >= 3) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 3) ) )
/* gcc >= 3.3 implicitly defines builtins for HUGE_VALx values. */
# ifndef HUGE_VAL
# define HUGE_VAL (__builtin_huge_val())
# endif
# ifndef HUGE_VALF
# define HUGE_VALF (__builtin_huge_valf())
# endif
# ifndef HUGE_VALL
# define HUGE_VALL (__builtin_huge_vall())
# endif
# ifndef INFINITY
# define INFINITY (__builtin_inff())
# endif
# ifndef NAN
# define NAN (__builtin_nanf(""))
# endif
#else /* !gcc >= 3.3 */
/* No builtins. Use fixed defines instead. (All 3 HUGE plus the INFINITY
* and NAN macros are required to be constant expressions. Using a variable--
* even a static const--does not meet this requirement, as it cannot be
* evaluated at translation time.)
* The infinities are done using numbers that are far in excess of
* something that would be expected to be encountered in a floating-point
* implementation. (A more certain way uses values from float.h, but that is
* avoided because system includes are not supposed to include each other.)
* This method might produce warnings from some compilers. (It does in
* newer GCCs, but not for ones that would hit this #else.) If this happens,
* please report details to the Newlib mailing list. */
#ifndef HUGE_VAL
#define HUGE_VAL (1.0e999999999)
#endif
#ifndef HUGE_VALF
#define HUGE_VALF (1.0e999999999F)
#endif
#if !defined(HUGE_VALL) && defined(_HAVE_LONG_DOUBLE)
#define HUGE_VALL (1.0e999999999L)
#endif
#if !defined(INFINITY)
#define INFINITY (HUGE_VALF)
#endif
#if !defined(NAN)
#if defined(__GNUC__) && defined(__cplusplus)
/* Exception: older g++ versions warn about the divide by 0 used in the
* normal case (even though older gccs do not). This trick suppresses the
* warning, but causes errors for plain gcc, so is only used in the one
* special case. */
static const union { __ULong __i[1]; float __d; } __Nanf = {0x7FC00000};
#define NAN (__Nanf.__d)
#else
#define NAN (0.0F/0.0F)
#endif
#endif
#endif /* !gcc >= 3.3 */
/* Reentrant ANSI C functions. */
#ifndef __math_68881
extern double atan _PARAMS((double));
extern double cos _PARAMS((double));
extern double sin _PARAMS((double));
extern double tan _PARAMS((double));
extern double tanh _PARAMS((double));
extern double frexp _PARAMS((double, int *));
extern double modf _PARAMS((double, double *));
extern double ceil _PARAMS((double));
extern double fabs _PARAMS((double));
extern double floor _PARAMS((double));
#endif /* ! defined (__math_68881) */
/* Non reentrant ANSI C functions. */
#ifndef _REENT_ONLY
#ifndef __math_68881
extern double acos _PARAMS((double));
extern double asin _PARAMS((double));
extern double atan2 _PARAMS((double, double));
extern double cosh _PARAMS((double));
extern double sinh _PARAMS((double));
extern double exp _PARAMS((double));
extern double ldexp _PARAMS((double, int));
extern double log _PARAMS((double));
extern double log10 _PARAMS((double));
extern double pow _PARAMS((double, double));
extern double sqrt _PARAMS((double));
extern double fmod _PARAMS((double, double));
#endif /* ! defined (__math_68881) */
#endif /* ! defined (_REENT_ONLY) */
#if !defined(__STRICT_ANSI__) || defined(__cplusplus) || __STDC_VERSION__ >= 199901L
/* ISO C99 types and macros. */
#ifndef FLT_EVAL_METHOD
#define FLT_EVAL_METHOD 0
typedef float float_t;
typedef double double_t;
#endif /* FLT_EVAL_METHOD */
#define FP_NAN 0
#define FP_INFINITE 1
#define FP_ZERO 2
#define FP_SUBNORMAL 3
#define FP_NORMAL 4
#ifndef FP_ILOGB0
# define FP_ILOGB0 (-INT_MAX)
#endif
#ifndef FP_ILOGBNAN
# define FP_ILOGBNAN INT_MAX
#endif
#ifndef MATH_ERRNO
# define MATH_ERRNO 1
#endif
#ifndef MATH_ERREXCEPT
# define MATH_ERREXCEPT 2
#endif
#ifndef math_errhandling
# define math_errhandling MATH_ERRNO
#endif
extern int __isinff (float x);
extern int __isinfd (double x);
extern int __isnanf (float x);
extern int __isnand (double x);
extern int __fpclassifyf (float x);
extern int __fpclassifyd (double x);
extern int __signbitf (float x);
extern int __signbitd (double x);
#define fpclassify(__x) \
((sizeof(__x) == sizeof(float)) ? __fpclassifyf(__x) : \
__fpclassifyd(__x))
#ifndef isfinite
#define isfinite(__y) \
(__extension__ ({int __cy = fpclassify(__y); \
__cy != FP_INFINITE && __cy != FP_NAN;}))
#endif
/* Note: isinf and isnan were once functions in newlib that took double
* arguments. C99 specifies that these names are reserved for macros
* supporting multiple floating point types. Thus, they are
* now defined as macros. Implementations of the old functions
* taking double arguments still exist for compatibility purposes
* (prototypes for them are in <ieeefp.h>). */
#ifndef isinf
#define isinf(y) (fpclassify(y) == FP_INFINITE)
#endif
#ifndef isnan
#define isnan(y) (fpclassify(y) == FP_NAN)
#endif
#define isnormal(y) (fpclassify(y) == FP_NORMAL)
#define signbit(__x) \
((sizeof(__x) == sizeof(float)) ? __signbitf(__x) : \
__signbitd(__x))
#define isgreater(x,y) \
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
!isunordered(__x,__y) && (__x > __y);}))
#define isgreaterequal(x,y) \
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
!isunordered(__x,__y) && (__x >= __y);}))
#define isless(x,y) \
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
!isunordered(__x,__y) && (__x < __y);}))
#define islessequal(x,y) \
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
!isunordered(__x,__y) && (__x <= __y);}))
#define islessgreater(x,y) \
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \
!isunordered(__x,__y) && (__x < __y || __x > __y);}))
#define isunordered(a,b) \
(__extension__ ({__typeof__(a) __a = (a); __typeof__(b) __b = (b); \
fpclassify(__a) == FP_NAN || fpclassify(__b) == FP_NAN;}))
/* Non ANSI double precision functions. */
extern double infinity _PARAMS((void));
extern double nan _PARAMS((const char *));
extern int finite _PARAMS((double));
extern double copysign _PARAMS((double, double));
extern double logb _PARAMS((double));
extern int ilogb _PARAMS((double));
extern double asinh _PARAMS((double));
extern double cbrt _PARAMS((double));
extern double nextafter _PARAMS((double, double));
extern double rint _PARAMS((double));
extern double scalbn _PARAMS((double, int));
extern double exp2 _PARAMS((double));
extern double scalbln _PARAMS((double, long int));
extern double tgamma _PARAMS((double));
extern double nearbyint _PARAMS((double));
extern long int lrint _PARAMS((double));
extern _LONG_LONG_TYPE int llrint _PARAMS((double));
extern double round _PARAMS((double));
extern long int lround _PARAMS((double));
extern long long int llround _PARAMS((double));
extern double trunc _PARAMS((double));
extern double remquo _PARAMS((double, double, int *));
extern double fdim _PARAMS((double, double));
extern double fmax _PARAMS((double, double));
extern double fmin _PARAMS((double, double));
extern double fma _PARAMS((double, double, double));
#ifndef __math_68881
extern double log1p _PARAMS((double));
extern double expm1 _PARAMS((double));
#endif /* ! defined (__math_68881) */
#ifndef _REENT_ONLY
extern double acosh _PARAMS((double));
extern double atanh _PARAMS((double));
extern double remainder _PARAMS((double, double));
extern double gamma _PARAMS((double));
extern double lgamma _PARAMS((double));
extern double erf _PARAMS((double));
extern double erfc _PARAMS((double));
extern double log2 _PARAMS((double));
#if !defined(__cplusplus)
#define log2(x) (log (x) / _M_LOG2_E)
#endif
#ifndef __math_68881
extern double hypot _PARAMS((double, double));
#endif
#endif /* ! defined (_REENT_ONLY) */
/* Single precision versions of ANSI functions. */
extern float atanf _PARAMS((float));
extern float cosf _PARAMS((float));
extern float sinf _PARAMS((float));
extern float tanf _PARAMS((float));
extern float tanhf _PARAMS((float));
extern float frexpf _PARAMS((float, int *));
extern float modff _PARAMS((float, float *));
extern float ceilf _PARAMS((float));
extern float fabsf _PARAMS((float));
extern float floorf _PARAMS((float));
#ifndef _REENT_ONLY
extern float acosf _PARAMS((float));
extern float asinf _PARAMS((float));
extern float atan2f _PARAMS((float, float));
extern float coshf _PARAMS((float));
extern float sinhf _PARAMS((float));
extern float expf _PARAMS((float));
extern float ldexpf _PARAMS((float, int));
extern float logf _PARAMS((float));
extern float log10f _PARAMS((float));
extern float powf _PARAMS((float, float));
extern float sqrtf _PARAMS((float));
extern float fmodf _PARAMS((float, float));
#endif /* ! defined (_REENT_ONLY) */
/* Other single precision functions. */
extern float exp2f _PARAMS((float));
extern float scalblnf _PARAMS((float, long int));
extern float tgammaf _PARAMS((float));
extern float nearbyintf _PARAMS((float));
extern long int lrintf _PARAMS((float));
extern _LONG_LONG_TYPE llrintf _PARAMS((float));
extern float roundf _PARAMS((float));
extern long int lroundf _PARAMS((float));
extern long long int llroundf _PARAMS((float));
extern float truncf _PARAMS((float));
extern float remquof _PARAMS((float, float, int *));
extern float fdimf _PARAMS((float, float));
extern float fmaxf _PARAMS((float, float));
extern float fminf _PARAMS((float, float));
extern float fmaf _PARAMS((float, float, float));
extern float infinityf _PARAMS((void));
extern float nanf _PARAMS((const char *));
extern int finitef _PARAMS((float));
extern float copysignf _PARAMS((float, float));
extern float logbf _PARAMS((float));
extern int ilogbf _PARAMS((float));
extern float asinhf _PARAMS((float));
extern float cbrtf _PARAMS((float));
extern float nextafterf _PARAMS((float, float));
extern float rintf _PARAMS((float));
extern float scalbnf _PARAMS((float, int));
extern float log1pf _PARAMS((float));
extern float expm1f _PARAMS((float));
#ifndef _REENT_ONLY
extern float acoshf _PARAMS((float));
extern float atanhf _PARAMS((float));
extern float remainderf _PARAMS((float, float));
extern float gammaf _PARAMS((float));
extern float lgammaf _PARAMS((float));
extern float erff _PARAMS((float));
extern float erfcf _PARAMS((float));
extern float log2f _PARAMS((float));
#if !defined(__cplusplus)
#define log2f(x) (logf (x) / (float) _M_LOG2_E)
#endif
extern float hypotf _PARAMS((float, float));
#endif /* ! defined (_REENT_ONLY) */
/* On platforms where long double equals double. */
#ifdef _LDBL_EQ_DBL
/* Reentrant ANSI C functions. */
#ifndef __math_68881
extern long double atanl _PARAMS((long double));
extern long double cosl _PARAMS((long double));
extern long double sinl _PARAMS((long double));
extern long double tanl _PARAMS((long double));
extern long double tanhl _PARAMS((long double));
extern long double frexpl _PARAMS((long double value, int *));
extern long double modfl _PARAMS((long double, long double *));
extern long double ceill _PARAMS((long double));
extern long double fabsl _PARAMS((long double));
extern long double floorl _PARAMS((long double));
extern long double log1pl _PARAMS((long double));
extern long double expm1l _PARAMS((long double));
#endif /* ! defined (__math_68881) */
/* Non reentrant ANSI C functions. */
#ifndef _REENT_ONLY
#ifndef __math_68881
extern long double acosl _PARAMS((long double));
extern long double asinl _PARAMS((long double));
extern long double atan2l _PARAMS((long double, long double));
extern long double coshl _PARAMS((long double));
extern long double sinhl _PARAMS((long double));
extern long double expl _PARAMS((long double));
extern long double ldexpl _PARAMS((long double, int));
extern long double logl _PARAMS((long double));
extern long double log10l _PARAMS((long double));
extern long double powl _PARAMS((long double, long double));
extern long double sqrtl _PARAMS((long double));
extern long double fmodl _PARAMS((long double, long double));
extern long double hypotl _PARAMS((long double, long double));
#endif /* ! defined (__math_68881) */
#endif /* ! defined (_REENT_ONLY) */
extern long double copysignl _PARAMS((long double, long double));
extern long double nanl _PARAMS((const char *));
extern int ilogbl _PARAMS((long double));
extern long double asinhl _PARAMS((long double));
extern long double cbrtl _PARAMS((long double));
extern long double nextafterl _PARAMS((long double, long double));
extern long double rintl _PARAMS((long double));
extern long double scalbnl _PARAMS((long double, int));
extern long double exp2l _PARAMS((long double));
extern long double scalblnl _PARAMS((long double, long));
extern long double tgammal _PARAMS((long double));
extern long double nearbyintl _PARAMS((long double));
extern long int lrintl _PARAMS((long double));
extern long long int llrintl _PARAMS((long double));
extern long double roundl _PARAMS((long double));
extern long lroundl _PARAMS((long double));
extern _LONG_LONG_TYPE int llroundl _PARAMS((long double));
extern long double truncl _PARAMS((long double));
extern long double remquol _PARAMS((long double, long double, int *));
extern long double fdiml _PARAMS((long double, long double));
extern long double fmaxl _PARAMS((long double, long double));
extern long double fminl _PARAMS((long double, long double));
extern long double fmal _PARAMS((long double, long double, long double));
#ifndef _REENT_ONLY
extern long double acoshl _PARAMS((long double));
extern long double atanhl _PARAMS((long double));
extern long double remainderl _PARAMS((long double, long double));
extern long double lgammal _PARAMS((long double));
extern long double erfl _PARAMS((long double));
extern long double erfcl _PARAMS((long double));
#endif /* ! defined (_REENT_ONLY) */
#else /* !_LDBL_EQ_DBL */
#ifdef __i386__
/* Other long double precision functions. */
extern _LONG_DOUBLE rintl _PARAMS((_LONG_DOUBLE));
extern long int lrintl _PARAMS((_LONG_DOUBLE));
extern _LONG_LONG_TYPE llrintl _PARAMS((_LONG_DOUBLE));
#endif /* __i386__ */
#endif /* !_LDBL_EQ_DBL */
#endif /* !defined (__STRICT_ANSI__) || defined(__cplusplus) || __STDC_VERSION__ >= 199901L */
#if !defined (__STRICT_ANSI__) || defined(__cplusplus)
extern double drem _PARAMS((double, double));
extern void sincos _PARAMS((double, double *, double *));
extern double gamma_r _PARAMS((double, int *));
extern double lgamma_r _PARAMS((double, int *));
extern double y0 _PARAMS((double));
extern double y1 _PARAMS((double));
extern double yn _PARAMS((int, double));
extern double j0 _PARAMS((double));
extern double j1 _PARAMS((double));
extern double jn _PARAMS((int, double));
extern float dremf _PARAMS((float, float));
extern void sincosf _PARAMS((float, float *, float *));
extern float gammaf_r _PARAMS((float, int *));
extern float lgammaf_r _PARAMS((float, int *));
extern float y0f _PARAMS((float));
extern float y1f _PARAMS((float));
extern float ynf _PARAMS((int, float));
extern float j0f _PARAMS((float));
extern float j1f _PARAMS((float));
extern float jnf _PARAMS((int, float));
/* GNU extensions */
# ifndef exp10
extern double exp10 _PARAMS((double));
# endif
# ifndef pow10
extern double pow10 _PARAMS((double));
# endif
# ifndef exp10f
extern float exp10f _PARAMS((float));
# endif
# ifndef pow10f
extern float pow10f _PARAMS((float));
# endif
#endif /* !defined (__STRICT_ANSI__) || defined(__cplusplus) */
#ifndef __STRICT_ANSI__
/* The gamma functions use a global variable, signgam. */
#ifndef _REENT_ONLY
#define signgam (*__signgam())
extern int *__signgam _PARAMS((void));
#endif /* ! defined (_REENT_ONLY) */
#define __signgam_r(ptr) _REENT_SIGNGAM(ptr)
/* The exception structure passed to the matherr routine. */
/* We have a problem when using C++ since `exception' is a reserved
name in C++. */
#ifdef __cplusplus
struct __exception
#else
struct exception
#endif
{
int type;
char *name;
double arg1;
double arg2;
double retval;
int err;
};
#ifdef __cplusplus
extern int matherr _PARAMS((struct __exception *e));
#else
extern int matherr _PARAMS((struct exception *e));
#endif
/* Values for the type field of struct exception. */
#define DOMAIN 1
#define SING 2
#define OVERFLOW 3
#define UNDERFLOW 4
#define TLOSS 5
#define PLOSS 6
/* Useful constants. */
#define MAXFLOAT 3.40282347e+38F
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_TWOPI (M_PI * 2.0)
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_3PI_4 2.3561944901923448370E0
#define M_SQRTPI 1.77245385090551602792981
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#define M_LN2LO 1.9082149292705877000E-10
#define M_LN2HI 6.9314718036912381649E-1
#define M_SQRT3 1.73205080756887719000
#define M_IVLN10 0.43429448190325182765 /* 1 / log(10) */
#define M_LOG2_E _M_LOG2_E
#define M_INVLN2 1.4426950408889633870E0 /* 1 / log(2) */
/* Global control over fdlibm error handling. */
enum __fdlibm_version
{
__fdlibm_ieee = -1,
__fdlibm_svid,
__fdlibm_xopen,
__fdlibm_posix
};
#define _LIB_VERSION_TYPE enum __fdlibm_version
#define _LIB_VERSION __fdlib_version
extern __IMPORT _LIB_VERSION_TYPE _LIB_VERSION;
#define _IEEE_ __fdlibm_ieee
#define _SVID_ __fdlibm_svid
#define _XOPEN_ __fdlibm_xopen
#define _POSIX_ __fdlibm_posix
#endif /* ! defined (__STRICT_ANSI__) */
_END_STD_C
#ifdef __FAST_MATH__
#include <machine/fastmath.h>
#endif
#endif /* _MATH_H_ */

19
programs/develop/libraries/newlib/include/newlib.h Normal file
View File

@ -0,0 +1,19 @@
/* dummy file for external tools to use. Real file is created by
newlib configuration. */
#ifndef _NEWLIB_H_
#define _NEWLIB_H_
#ifdef __LIBC_DLL__
#ifdef __LIBC_EXPORT__
#define API __attribute__ ((dllexport))
#else
#define API __attribute__ ((dllimport))
#endif
#else
#define API
#endif
#endif /* _NEWLIB_H_ */

7
programs/develop/libraries/newlib/include/paths.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef _PATHS_H_
#define _PATHS_H_
#define _PATH_DEV "/dev/"
#define _PATH_BSHELL "/bin/sh"
#endif /* _PATHS_H_ */

44
programs/develop/libraries/newlib/include/process.h Normal file
View File

@ -0,0 +1,44 @@
/* process.h. This file comes with MSDOS and WIN32 systems. */
#ifndef __PROCESS_H_
#define __PROCESS_H_
#ifdef __cplusplus
extern "C" {
#endif
int execl(const char *path, const char *argv0, ...);
int execle(const char *path, const char *argv0, ... /*, char * const *envp */);
int execlp(const char *path, const char *argv0, ...);
int execlpe(const char *path, const char *argv0, ... /*, char * const *envp */);
int execv(const char *path, char * const *argv);
int execve(const char *path, char * const *argv, char * const *envp);
int execvp(const char *path, char * const *argv);
int execvpe(const char *path, char * const *argv, char * const *envp);
int spawnl(int mode, const char *path, const char *argv0, ...);
int spawnle(int mode, const char *path, const char *argv0, ... /*, char * const *envp */);
int spawnlp(int mode, const char *path, const char *argv0, ...);
int spawnlpe(int mode, const char *path, const char *argv0, ... /*, char * const *envp */);
int spawnv(int mode, const char *path, const char * const *argv);
int spawnve(int mode, const char *path, const char * const *argv, const char * const *envp);
int spawnvp(int mode, const char *path, const char * const *argv);
int spawnvpe(int mode, const char *path, const char * const *argv, const char * const *envp);
int cwait(int *, int, int);
#define _P_WAIT 1
#define _P_NOWAIT 2 /* always generates error */
#define _P_OVERLAY 3
#define _P_NOWAITO 4
#define _P_DETACH 5
#define WAIT_CHILD 1
#ifdef __cplusplus
}
#endif
#endif

351
programs/develop/libraries/newlib/include/pthread.h Normal file
View File

@ -0,0 +1,351 @@
/* pthread.h
*
* Written by Joel Sherrill <joel@OARcorp.com>.
*
* COPYRIGHT (c) 1989-2000.
* On-Line Applications Research Corporation (OAR).
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION
* OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
* SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
* $Id: pthread.h,v 1.8 2009/12/17 19:22:23 jjohnstn Exp $
*/
#ifndef __PTHREAD_h
#define __PTHREAD_h
#ifdef __cplusplus
extern "C" {
#endif
#include <unistd.h>
#if defined(_POSIX_THREADS)
#include <sys/types.h>
#include <time.h>
#include <sys/sched.h>
/* Register Fork Handlers */
int _EXFUN(pthread_atfork,(void (*prepare)(void), void (*parent)(void),
void (*child)(void)));
/* Mutex Initialization Attributes, P1003.1c/Draft 10, p. 81 */
int _EXFUN(pthread_mutexattr_init, (pthread_mutexattr_t *__attr));
int _EXFUN(pthread_mutexattr_destroy, (pthread_mutexattr_t *__attr));
int _EXFUN(pthread_mutexattr_getpshared,
(_CONST pthread_mutexattr_t *__attr, int *__pshared));
int _EXFUN(pthread_mutexattr_setpshared,
(pthread_mutexattr_t *__attr, int __pshared));
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/* Single UNIX Specification 2 Mutex Attributes types */
int _EXFUN(pthread_mutexattr_gettype,
(_CONST pthread_mutexattr_t *__attr, int *__kind));
int _EXFUN(pthread_mutexattr_settype,
(pthread_mutexattr_t *__attr, int __kind));
#endif
/* Initializing and Destroying a Mutex, P1003.1c/Draft 10, p. 87 */
int _EXFUN(pthread_mutex_init,
(pthread_mutex_t *__mutex, _CONST pthread_mutexattr_t *__attr));
int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *__mutex));
/* This is used to statically initialize a pthread_mutex_t. Example:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
*/
#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) 0xFFFFFFFF)
/* Locking and Unlocking a Mutex, P1003.1c/Draft 10, p. 93
NOTE: P1003.4b/D8 adds pthread_mutex_timedlock(), p. 29 */
int _EXFUN(pthread_mutex_lock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
(pthread_mutex_t *__mutex, _CONST struct timespec *__timeout));
#endif /* _POSIX_TIMEOUTS */
/* Condition Variable Initialization Attributes, P1003.1c/Draft 10, p. 96 */
int _EXFUN(pthread_condattr_init, (pthread_condattr_t *__attr));
int _EXFUN(pthread_condattr_destroy, (pthread_condattr_t *__attr));
int _EXFUN(pthread_condattr_getpshared,
(_CONST pthread_condattr_t *__attr, int *__pshared));
int _EXFUN(pthread_condattr_setpshared,
(pthread_condattr_t *__attr, int __pshared));
/* Initializing and Destroying a Condition Variable, P1003.1c/Draft 10, p. 87 */
int _EXFUN(pthread_cond_init,
(pthread_cond_t *__cond, _CONST pthread_condattr_t *__attr));
int _EXFUN(pthread_cond_destroy, (pthread_cond_t *__mutex));
/* This is used to statically initialize a pthread_cond_t. Example:
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
*/
#define PTHREAD_COND_INITIALIZER ((pthread_mutex_t) 0xFFFFFFFF)
/* Broadcasting and Signaling a Condition, P1003.1c/Draft 10, p. 101 */
int _EXFUN(pthread_cond_signal, (pthread_cond_t *__cond));
int _EXFUN(pthread_cond_broadcast, (pthread_cond_t *__cond));
/* Waiting on a Condition, P1003.1c/Draft 10, p. 105 */
int _EXFUN(pthread_cond_wait,
(pthread_cond_t *__cond, pthread_mutex_t *__mutex));
int _EXFUN(pthread_cond_timedwait,
(pthread_cond_t *__cond, pthread_mutex_t *__mutex,
_CONST struct timespec *__abstime));
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
/* Thread Creation Scheduling Attributes, P1003.1c/Draft 10, p. 120 */
int _EXFUN(pthread_attr_setscope,
(pthread_attr_t *__attr, int __contentionscope));
int _EXFUN(pthread_attr_getscope,
(_CONST pthread_attr_t *__attr, int *__contentionscope));
int _EXFUN(pthread_attr_setinheritsched,
(pthread_attr_t *__attr, int __inheritsched));
int _EXFUN(pthread_attr_getinheritsched,
(_CONST pthread_attr_t *__attr, int *__inheritsched));
int _EXFUN(pthread_attr_setschedpolicy,
(pthread_attr_t *__attr, int __policy));
int _EXFUN(pthread_attr_getschedpolicy,
(_CONST pthread_attr_t *__attr, int *__policy));
#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */
int _EXFUN(pthread_attr_setschedparam,
(pthread_attr_t *__attr, _CONST struct sched_param *__param));
int _EXFUN(pthread_attr_getschedparam,
(_CONST pthread_attr_t *__attr, struct sched_param *__param));
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
/* Dynamic Thread Scheduling Parameters Access, P1003.1c/Draft 10, p. 124 */
int _EXFUN(pthread_getschedparam,
(pthread_t __pthread, int *__policy, struct sched_param *__param));
int _EXFUN(pthread_setschedparam,
(pthread_t __pthread, int __policy, struct sched_param *__param));
#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */
#if defined(_POSIX_THREAD_PRIO_INHERIT) || defined(_POSIX_THREAD_PRIO_PROTECT)
/* Mutex Initialization Scheduling Attributes, P1003.1c/Draft 10, p. 128 */
int _EXFUN(pthread_mutexattr_setprotocol,
(pthread_mutexattr_t *__attr, int __protocol));
int _EXFUN(pthread_mutexattr_getprotocol,
(_CONST pthread_mutexattr_t *__attr, int *__protocol));
int _EXFUN(pthread_mutexattr_setprioceiling,
(pthread_mutexattr_t *__attr, int __prioceiling));
int _EXFUN(pthread_mutexattr_getprioceiling,
(_CONST pthread_mutexattr_t *__attr, int *__prioceiling));
#endif /* _POSIX_THREAD_PRIO_INHERIT || _POSIX_THREAD_PRIO_PROTECT */
#if defined(_POSIX_THREAD_PRIO_PROTECT)
/* Change the Priority Ceiling of a Mutex, P1003.1c/Draft 10, p. 131 */
int _EXFUN(pthread_mutex_setprioceiling,
(pthread_mutex_t *__mutex, int __prioceiling, int *__old_ceiling));
int _EXFUN(pthread_mutex_getprioceiling,
(pthread_mutex_t *__mutex, int *__prioceiling));
#endif /* _POSIX_THREAD_PRIO_PROTECT */
/* Thread Creation Attributes, P1003.1c/Draft 10, p, 140 */
int _EXFUN(pthread_attr_init, (pthread_attr_t *__attr));
int _EXFUN(pthread_attr_destroy, (pthread_attr_t *__attr));
int _EXFUN(pthread_attr_getstacksize,
(_CONST pthread_attr_t *__attr, size_t *__stacksize));
int _EXFUN(pthread_attr_setstacksize,
(pthread_attr_t *__attr, size_t stacksize));
int _EXFUN(pthread_attr_getstackaddr,
(_CONST pthread_attr_t *__attr, void **__stackaddr));
int _EXFUN(pthread_attr_setstackaddr,
(pthread_attr_t *__attr, void *__stackaddr));
int _EXFUN(pthread_attr_getdetachstate,
(_CONST pthread_attr_t *__attr, int *__detachstate));
int _EXFUN(pthread_attr_setdetachstate,
(pthread_attr_t *__attr, int __detachstate));
/* Thread Creation, P1003.1c/Draft 10, p. 144 */
int _EXFUN(pthread_create,
(pthread_t *__pthread, _CONST pthread_attr_t *__attr,
void *(*__start_routine)( void * ), void *__arg));
/* Wait for Thread Termination, P1003.1c/Draft 10, p. 147 */
int _EXFUN(pthread_join, (pthread_t __pthread, void **__value_ptr));
/* Detaching a Thread, P1003.1c/Draft 10, p. 149 */
int _EXFUN(pthread_detach, (pthread_t __pthread));
/* Thread Termination, p1003.1c/Draft 10, p. 150 */
void _EXFUN(pthread_exit, (void *__value_ptr));
/* Get Calling Thread's ID, p1003.1c/Draft 10, p. XXX */
pthread_t _EXFUN(pthread_self, (void));
/* Compare Thread IDs, p1003.1c/Draft 10, p. 153 */
int _EXFUN(pthread_equal, (pthread_t __t1, pthread_t __t2));
/* Dynamic Package Initialization */
/* This is used to statically initialize a pthread_once_t. Example:
pthread_once_t once = PTHREAD_ONCE_INIT;
NOTE: This is named inconsistently -- it should be INITIALIZER. */
#define PTHREAD_ONCE_INIT { 1, 0 } /* is initialized and not run */
int _EXFUN(pthread_once,
(pthread_once_t *__once_control, void (*__init_routine)(void)));
/* Thread-Specific Data Key Create, P1003.1c/Draft 10, p. 163 */
int _EXFUN(pthread_key_create,
(pthread_key_t *__key, void (*__destructor)( void * )));
/* Thread-Specific Data Management, P1003.1c/Draft 10, p. 165 */
int _EXFUN(pthread_setspecific,
(pthread_key_t __key, _CONST void *__value));
void * _EXFUN(pthread_getspecific, (pthread_key_t __key));
/* Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */
int _EXFUN(pthread_key_delete, (pthread_key_t __key));
/* Execution of a Thread, P1003.1c/Draft 10, p. 181 */
#define PTHREAD_CANCEL_ENABLE 0
#define PTHREAD_CANCEL_DISABLE 1
#define PTHREAD_CANCEL_DEFERRED 0
#define PTHREAD_CANCEL_ASYNCHRONOUS 1
#define PTHREAD_CANCELED ((void *) -1)
int _EXFUN(pthread_cancel, (pthread_t __pthread));
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
/* Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184 */
void _EXFUN(pthread_cleanup_push,
(void (*__routine)( void * ), void *__arg));
void _EXFUN(pthread_cleanup_pop, (int __execute));
#if defined(_POSIX_THREAD_CPUTIME)
/* Accessing a Thread CPU-time Clock, P1003.4b/D8, p. 58 */
int _EXFUN(pthread_getcpuclockid,
(pthread_t __pthread_id, clockid_t *__clock_id));
#endif /* defined(_POSIX_THREAD_CPUTIME) */
#endif /* defined(_POSIX_THREADS) */
#if defined(_POSIX_BARRIERS)
int _EXFUN(pthread_barrierattr_init, (pthread_barrierattr_t *__attr));
int _EXFUN(pthread_barrierattr_destroy, (pthread_barrierattr_t *__attr));
int _EXFUN(pthread_barrierattr_getpshared,
(_CONST pthread_barrierattr_t *__attr, int *__pshared));
int _EXFUN(pthread_barrierattr_setpshared,
(pthread_barrierattr_t *__attr, int __pshared));
#define PTHREAD_BARRIER_SERIAL_THREAD -1
int _EXFUN(pthread_barrier_init,
(pthread_barrier_t *__barrier,
_CONST pthread_barrierattr_t *__attr, unsigned __count));
int _EXFUN(pthread_barrier_destroy, (pthread_barrier_t *__barrier));
int _EXFUN(pthread_barrier_wait,(pthread_barrier_t *__barrier));
#endif /* defined(_POSIX_BARRIERS) */
#if defined(_POSIX_SPIN_LOCKS)
int _EXFUN(pthread_spin_init,
(pthread_spinlock_t *__spinlock, int __pshared));
int _EXFUN(pthread_spin_destroy, (pthread_spinlock_t *__spinlock));
int _EXFUN(pthread_spin_lock, (pthread_spinlock_t *__spinlock));
int _EXFUN(pthread_spin_trylock, (pthread_spinlock_t *__spinlock));
int _EXFUN(pthread_spin_unlock, (pthread_spinlock_t *__spinlock));
#endif /* defined(_POSIX_SPIN_LOCKS) */
#if defined(_POSIX_READER_WRITER_LOCKS)
int _EXFUN(pthread_rwlockattr_init, (pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlockattr_destroy, (pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlockattr_getpshared,
(_CONST pthread_rwlockattr_t *__attr, int *__pshared));
int _EXFUN(pthread_rwlockattr_setpshared,
(pthread_rwlockattr_t *__attr, int __pshared));
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
#endif /* defined(_POSIX_READER_WRITER_LOCKS) */
#ifdef __cplusplus
}
#endif
#endif
/* end of include file */

78
programs/develop/libraries/newlib/include/pwd.h Normal file
View File

@ -0,0 +1,78 @@
/*-
* Copyright (c) 1989 The Regents of the University of California.
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)pwd.h 5.13 (Berkeley) 5/28/91
*/
#ifndef _PWD_H_
#ifdef __cplusplus
extern "C" {
#endif
#define _PWD_H_
#include <sys/types.h>
#ifndef _POSIX_SOURCE
#define _PATH_PASSWD "/etc/passwd"
#define _PASSWORD_LEN 128 /* max length, not counting NULL */
#endif
struct passwd {
char *pw_name; /* user name */
char *pw_passwd; /* encrypted password */
uid_t pw_uid; /* user uid */
gid_t pw_gid; /* user gid */
char *pw_comment; /* comment */
char *pw_gecos; /* Honeywell login info */
char *pw_dir; /* home directory */
char *pw_shell; /* default shell */
};
#ifndef __INSIDE_CYGWIN__
struct passwd *getpwuid (uid_t);
struct passwd *getpwnam (const char *);
int getpwnam_r (const char *, struct passwd *,
char *, size_t , struct passwd **);
int getpwuid_r (uid_t, struct passwd *, char *,
size_t, struct passwd **);
#ifndef _POSIX_SOURCE
struct passwd *getpwent (void);
void setpwent (void);
void endpwent (void);
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* _PWD_H_ */

191
programs/develop/libraries/newlib/include/reent.h Normal file
View File

@ -0,0 +1,191 @@
/* This header file provides the reentrancy. */
/* The reentrant system calls here serve two purposes:
1) Provide reentrant versions of the system calls the ANSI C library
requires.
2) Provide these system calls in a namespace clean way.
It is intended that *all* system calls that the ANSI C library needs
be declared here. It documents them all in one place. All library access
to the system is via some form of these functions.
The target may provide the needed syscalls by any of the following:
1) Define the reentrant versions of the syscalls directly.
(eg: _open_r, _close_r, etc.). Please keep the namespace clean.
When you do this, set "syscall_dir" to "syscalls" and add
-DREENTRANT_SYSCALLS_PROVIDED to newlib_cflags in configure.host.
2) Define namespace clean versions of the system calls by prefixing
them with '_' (eg: _open, _close, etc.). Technically, there won't be
true reentrancy at the syscall level, but the library will be namespace
clean.
When you do this, set "syscall_dir" to "syscalls" in configure.host.
3) Define or otherwise provide the regular versions of the syscalls
(eg: open, close, etc.). The library won't be reentrant nor namespace
clean, but at least it will work.
When you do this, add -DMISSING_SYSCALL_NAMES to newlib_cflags in
configure.host.
4) Define or otherwise provide the regular versions of the syscalls,
and do not supply functional interfaces for any of the reentrant
calls. With this method, the reentrant syscalls are redefined to
directly call the regular system call without the reentrancy argument.
When you do this, specify both -DREENTRANT_SYSCALLS_PROVIDED and
-DMISSING_SYSCALL_NAMES via newlib_cflags in configure.host and do
not specify "syscall_dir".
Stubs of the reentrant versions of the syscalls exist in the libc/reent
source directory and are provided if REENTRANT_SYSCALLS_PROVIDED isn't
defined. These stubs call the native system calls: _open, _close, etc.
if MISSING_SYSCALL_NAMES is *not* defined, otherwise they call the
non-underscored versions: open, close, etc. when MISSING_SYSCALL_NAMES
*is* defined.
By default, newlib functions call the reentrant syscalls internally,
passing a reentrancy structure as an argument. This reentrancy structure
contains data that is thread-specific. For example, the errno value is
kept in the reentrancy structure. If multiple threads exist, each will
keep a separate errno value which is intuitive since the application flow
cannot check for failure reliably otherwise.
The reentrant syscalls are either provided by the platform, by the
libc/reent stubs, or in the case of both MISSING_SYSCALL_NAMES and
REENTRANT_SYSCALLS_PROVIDED being defined, the calls are redefined to
simply call the regular syscalls with no reentrancy struct argument.
A single-threaded application does not need to worry about the reentrancy
structure. It is used internally.
A multi-threaded application needs either to manually manage reentrancy
structures or use dynamic reentrancy.
Manually managing reentrancy structures entails calling special reentrant
versions of newlib functions that have an additional reentrancy argument.
For example, _printf_r. By convention, the first argument is the
reentrancy structure. By default, the normal version of the function
uses the default reentrancy structure: _REENT. The reentrancy structure
is passed internally, eventually to the reentrant syscalls themselves.
How the structures are stored and accessed in this model is up to the
application.
Dynamic reentrancy is specified by the __DYNAMIC_REENT__ flag. This
flag denotes setting up a macro to replace _REENT with a function call
to __getreent(). This function needs to be implemented by the platform
and it is meant to return the reentrancy structure for the current
thread. When the regular C functions (e.g. printf) go to call internal
routines with the default _REENT structure, they end up calling with
the reentrancy structure for the thread. Thus, application code does not
need to call the _r routines nor worry about reentrancy structures. */
/* WARNING: All identifiers here must begin with an underscore. This file is
included by stdio.h and others and we therefore must only use identifiers
in the namespace allotted to us. */
#ifndef _REENT_H_
#ifdef __cplusplus
extern "C" {
#endif
#define _REENT_H_
#include <sys/reent.h>
#include <sys/_types.h>
#include <machine/types.h>
#define __need_size_t
#define __need_ptrdiff_t
#include <stddef.h>
/* FIXME: not namespace clean */
struct stat;
struct tms;
struct timeval;
struct timezone;
typedef struct
{
char *name;
unsigned int offset;
int (*write)(const char*, const void *, size_t, size_t, size_t*);
}__file_handle;
#if defined(REENTRANT_SYSCALLS_PROVIDED) && defined(MISSING_SYSCALL_NAMES)
#define _close_r(__reent, __fd) close(__fd)
#define _execve_r(__reent, __f, __arg, __env) execve(__f, __arg, __env)
#define _fcntl_r(__reent, __fd, __cmd, __arg) fcntl(__fd, __cmd, __arg)
#define _fork_r(__reent) fork()
#define _fstat_r(__reent, __fdes, __stat) fstat(__fdes, __stat)
#define _getpid_r(__reent) getpid()
#define _isatty_r(__reent, __desc) isatty(__desc)
#define _kill_r(__reent, __pid, __signal) kill(__pid, __signal)
#define _link_r(__reent, __oldpath, __newpath) link(__oldpath, __newpath)
#define _lseek_r(__reent, __fdes, __off, __w) lseek(__fdes, __off, __w)
#define _mkdir_r(__reent, __path, __m) mkdir(__path, __m)
#define _open_r(__reent, __path, __flag, __m) open(__path, __flag, __m)
#define _read_r(__reent, __fd, __buff, __cnt) read(__fd, __buff, __cnt)
#define _rename_r(__reent, __old, __new) rename(__old, __new)
#define _sbrk_r(__reent, __incr) sbrk(__incr)
#define _stat_r(__reent, __path, __buff) stat(__path, __buff)
#define _times_r(__reent, __time) times(__time)
#define _unlink_r(__reent, __path) unlink(__path)
#define _wait_r(__reent, __status) wait(__status)
#define _write_r(__reent, __fd, __buff, __cnt) write(__fd, __buff, __cnt)
#define _gettimeofday_r(__reent, __tp, __tzp) gettimeofday(__tp, __tzp)
#ifdef __LARGE64_FILES
#define _lseek64_r(__reent, __fd, __off, __w) lseek64(__fd, __off, __w)
#define _fstat64_r(__reent, __fd, __buff) fstat64(__fd, __buff)
#define _open64_r(__reent, __path, __flag, __m) open64(__path, __flag, __m)
#endif
#else
/* Reentrant versions of system calls. */
extern int _close_r _PARAMS ((struct _reent *, int));
extern int _execve_r _PARAMS ((struct _reent *, const char *, char *const *, char *const *));
extern int _fcntl_r _PARAMS ((struct _reent *, int, int, int));
extern int _fork_r _PARAMS ((struct _reent *));
extern int _fstat_r _PARAMS ((struct _reent *, int, struct stat *));
extern int _getpid_r _PARAMS ((struct _reent *));
extern int _isatty_r _PARAMS ((struct _reent *, int));
extern int _kill_r _PARAMS ((struct _reent *, int, int));
extern int _link_r _PARAMS ((struct _reent *, const char *, const char *));
extern _off_t _lseek_r _PARAMS ((struct _reent *, int, _off_t, int));
extern int _mkdir_r _PARAMS ((struct _reent *, const char *, int));
extern int _open_r _PARAMS ((struct _reent *, const char *, int, int));
extern _ssize_t _read_r _PARAMS ((struct _reent *, int, void *, size_t));
extern int _rename_r _PARAMS ((struct _reent *, const char *, const char *));
extern void *_sbrk_r _PARAMS ((struct _reent *, ptrdiff_t));
extern int _stat_r _PARAMS ((struct _reent *, const char *, struct stat *));
extern _CLOCK_T_ _times_r _PARAMS ((struct _reent *, struct tms *));
extern int _unlink_r _PARAMS ((struct _reent *, const char *));
extern int _wait_r _PARAMS ((struct _reent *, int *));
extern _ssize_t _write_r _PARAMS ((struct _reent *, int, const void *, size_t));
/* This one is not guaranteed to be available on all targets. */
extern int _gettimeofday_r _PARAMS ((struct _reent *, struct timeval *__tp, void *__tzp));
#ifdef __LARGE64_FILES
#if defined(__CYGWIN__) && defined(_COMPILING_NEWLIB)
#define stat64 __stat64
#endif
struct stat64;
extern _off64_t _lseek64_r _PARAMS ((struct _reent *, int, _off64_t, int));
extern int _fstat64_r _PARAMS ((struct _reent *, int, struct stat64 *));
extern int _open64_r _PARAMS ((struct _reent *, const char *, int, int));
extern int _stat64_r _PARAMS ((struct _reent *, const char *, struct stat64 *));
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* _REENT_H_ */

7
programs/develop/libraries/newlib/include/regdef.h Normal file
View File

@ -0,0 +1,7 @@
/* regdef.h -- define register names. */
/* This is a standard include file for MIPS targets. Other target
probably don't define it, and attempts to include this file will
fail. */
#include <machine/regdef.h>

102
programs/develop/libraries/newlib/include/regex.h Normal file
View File

@ -0,0 +1,102 @@
/*-
* Copyright (c) 1992 Henry Spencer.
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Henry Spencer of the University of Toronto.
*
* 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.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)regex.h 8.2 (Berkeley) 1/3/94
* $FreeBSD: src/include/regex.h,v 1.4 2002/03/23 17:24:53 imp Exp $
*/
#ifndef _REGEX_H_
#define _REGEX_H_
#include <sys/cdefs.h>
/* types */
typedef off_t regoff_t;
typedef struct {
int re_magic;
size_t re_nsub; /* number of parenthesized subexpressions */
__const char *re_endp; /* end pointer for REG_PEND */
struct re_guts *re_g; /* none of your business :-) */
} regex_t;
typedef struct {
regoff_t rm_so; /* start of match */
regoff_t rm_eo; /* end of match */
} regmatch_t;
/* regcomp() flags */
#define REG_BASIC 0000
#define REG_EXTENDED 0001
#define REG_ICASE 0002
#define REG_NOSUB 0004
#define REG_NEWLINE 0010
#define REG_NOSPEC 0020
#define REG_PEND 0040
#define REG_DUMP 0200
/* regerror() flags */
#define REG_NOMATCH 1
#define REG_BADPAT 2
#define REG_ECOLLATE 3
#define REG_ECTYPE 4
#define REG_EESCAPE 5
#define REG_ESUBREG 6
#define REG_EBRACK 7
#define REG_EPAREN 8
#define REG_EBRACE 9
#define REG_BADBR 10
#define REG_ERANGE 11
#define REG_ESPACE 12
#define REG_BADRPT 13
#define REG_EMPTY 14
#define REG_ASSERT 15
#define REG_INVARG 16
#define REG_ATOI 255 /* convert name to number (!) */
#define REG_ITOA 0400 /* convert number to name (!) */
/* regexec() flags */
#define REG_NOTBOL 00001
#define REG_NOTEOL 00002
#define REG_STARTEND 00004
#define REG_TRACE 00400 /* tracing of execution */
#define REG_LARGE 01000 /* force large representation */
#define REG_BACKR 02000 /* force use of backref code */
__BEGIN_DECLS
int regcomp(regex_t *, const char *, int);
size_t regerror(int, const regex_t *, char *, size_t);
int regexec(const regex_t *, const char *, size_t, regmatch_t [], int);
void regfree(regex_t *);
__END_DECLS
#endif /* !_REGEX_H_ */

85
programs/develop/libraries/newlib/include/rpc/types.h Normal file
View File

@ -0,0 +1,85 @@
/*
* Copyright (c) 2009, Sun Microsystems, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - 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.
* - Neither the name of Sun Microsystems, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*
* from: @(#)types.h 1.18 87/07/24 SMI
* from: @(#)types.h 2.3 88/08/15 4.0 RPCSRC
* $FreeBSD: src/include/rpc/types.h,v 1.10.6.1 2003/12/18 00:59:50 peter Exp $
* $NetBSD: types.h,v 1.13 2000/06/13 01:02:44 thorpej Exp $
*/
/*
* Rpc additions to <sys/types.h>
*/
#ifndef _RPC_TYPES_H
#define _RPC_TYPES_H
#include <stdint.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
#if defined(___int64_t_defined)
typedef u_int64_t u_quad_t;
typedef int64_t quad_t;
#endif /* ___int64_t_defined */
typedef int32_t bool_t;
typedef int32_t enum_t;
typedef u_int32_t rpcprog_t;
typedef u_int32_t rpcvers_t;
typedef u_int32_t rpcproc_t;
typedef u_int32_t rpcprot_t;
typedef u_int32_t rpcport_t;
typedef int32_t rpc_inline_t;
#ifndef NULL
# define NULL 0
#endif
#define __dontcare__ -1
#ifndef FALSE
# define FALSE 0
#endif
#ifndef TRUE
# define TRUE 1
#endif
#ifndef mem_alloc
#define mem_alloc(bsize) calloc(1, bsize)
#endif
#ifndef mem_free
#define mem_free(ptr, bsize) free(ptr)
#endif
#ifdef __cplusplus
}
#endif
#endif /* !_RPC_TYPES_H */

389
programs/develop/libraries/newlib/include/rpc/xdr.h Normal file
View File

@ -0,0 +1,389 @@
/*
* Copyright (c) 2009, Sun Microsystems, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - 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.
* - Neither the name of Sun Microsystems, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*
* from: @(#)xdr.h 1.19 87/04/22 SMI
* from: @(#)xdr.h 2.2 88/07/29 4.0 RPCSRC
* $FreeBSD: src/include/rpc/xdr.h,v 1.23 2003/03/07 13:19:40 nectar Exp $
* $NetBSD: xdr.h,v 1.19 2000/07/17 05:00:45 matt Exp $
*/
/*
* xdr.h, External Data Representation Serialization Routines.
*
* Copyright (C) 1984, Sun Microsystems, Inc.
*/
#ifndef _RPC_XDR_H
#define _RPC_XDR_H
#include <_ansi.h>
#include <rpc/types.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* XDR provides a conventional way for converting between C data
* types and an external bit-string representation. Library supplied
* routines provide for the conversion on built-in C data types. These
* routines and utility routines defined here are used to help implement
* a type encode/decode routine for each user-defined type.
*
* Each data type provides a single procedure which takes two arguments:
*
* bool_t
* xdrproc(XDR *xdrs, <type> *argresp)
*
* xdrs is an instance of a XDR handle, to which or from which the data
* type is to be converted. argresp is a pointer to the structure to be
* converted. The XDR handle contains an operation field which indicates
* which of the operations (ENCODE, DECODE * or FREE) is to be performed.
*
* XDR_DECODE may allocate space if the pointer argresp is null. This
* data can be freed with the XDR_FREE operation.
*
* We write only one procedure per data type to make it easy
* to keep the encode and decode procedures for a data type consistent.
* In many cases the same code performs all operations on a user defined type,
* because all the hard work is done in the component type routines.
* decode as a series of calls on the nested data types.
*/
/*
* Xdr operations. XDR_ENCODE causes the type to be encoded into the
* stream. XDR_DECODE causes the type to be extracted from the stream.
* XDR_FREE can be used to release the space allocated by an XDR_DECODE
* request.
*/
enum xdr_op
{
XDR_ENCODE = 0,
XDR_DECODE = 1,
XDR_FREE = 2
};
/*
* This is the number of bytes per unit of external data.
*/
#define BYTES_PER_XDR_UNIT (4)
#if 1
/* faster version when BYTES_PER_XDR_UNIT is a power of two */
# define RNDUP(x) (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))
#else /* old version */
#define RNDUP(x) ((((x) + BYTES_PER_XDR_UNIT - 1) / BYTES_PER_XDR_UNIT) \
* BYTES_PER_XDR_UNIT)
#endif
/*
* The XDR handle.
* Contains operation which is being applied to the stream,
* an operations vector for the particular implementation (e.g. see xdr_mem.c),
* and two private fields for the use of the particular implementation.
*/
typedef struct __rpc_xdr
{
enum xdr_op x_op; /* operation; fast additional param */
_CONST struct xdr_ops
{
/* get a long from underlying stream */
bool_t _EXFNPTR (x_getlong, (struct __rpc_xdr *, long *));
/* put a long to " */
bool_t _EXFNPTR (x_putlong, (struct __rpc_xdr *, _CONST long *));
/* get some bytes from " */
bool_t _EXFNPTR (x_getbytes, (struct __rpc_xdr *, char *, u_int));
/* put some bytes to " */
bool_t _EXFNPTR (x_putbytes, (struct __rpc_xdr *, _CONST char *, u_int));
/* returns bytes off from beginning */
u_int _EXFNPTR (x_getpostn, (struct __rpc_xdr *));
/* lets you reposition the stream */
bool_t _EXFNPTR (x_setpostn, (struct __rpc_xdr *, u_int));
/* buf quick ptr to buffered data */
int32_t * _EXFNPTR (x_inline, (struct __rpc_xdr *, u_int));
/* free privates of this xdr_stream */
void _EXFNPTR (x_destroy, (struct __rpc_xdr *));
/* get an int32 from this xdr_stream */
bool_t _EXFNPTR (x_getint32, (struct __rpc_xdr *, int32_t *));
/* put an int32 to the underlying stream */
bool_t _EXFNPTR (x_putint32, (struct __rpc_xdr *, _CONST int32_t *));
} *x_ops;
char *x_public; /* users' data */
void *x_private; /* pointer to private data */
char *x_base; /* private used for position info */
u_int x_handy; /* extra private word */
} XDR;
/*
* A xdrproc_t exists for each data type which is to be encoded or decoded.
*
* The second argument to the xdrproc_t is a pointer to an opaque pointer.
* The opaque pointer generally points to a structure of the data type
* to be decoded. If this pointer is 0, then the type routines should
* allocate dynamic storage of the appropriate size and return it.
* bool_t (*xdrproc_t)(XDR *, some_type *)
*/
typedef bool_t _EXFNPTR(xdrproc_t, (XDR *, ...));
/*
* Operations defined on a XDR handle
*
* XDR *xdrs;
* long *longp;
* char *addr;
* u_int len;
* u_int pos;
*/
#define XDR_GETINT32(xdrs, int32p) \
(*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define xdr_getint32(xdrs, int32p) \
(*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define XDR_PUTINT32(xdrs, int32p) \
(*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define xdr_putint32(xdrs, int32p) \
(*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define XDR_GETLONG(xdrs, longp) \
(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define xdr_getlong(xdrs, longp) \
(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define XDR_PUTLONG(xdrs, longp) \
(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define xdr_putlong(xdrs, longp) \
(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define XDR_GETBYTES(xdrs, addr, len) \
(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define xdr_getbytes(xdrs, addr, len) \
(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define XDR_PUTBYTES(xdrs, addr, len) \
(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define xdr_putbytes(xdrs, addr, len) \
(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define XDR_GETPOS(xdrs) \
(*(xdrs)->x_ops->x_getpostn)(xdrs)
#define xdr_getpos(xdrs) \
(*(xdrs)->x_ops->x_getpostn)(xdrs)
#define XDR_SETPOS(xdrs, pos) \
(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define xdr_setpos(xdrs, pos) \
(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define XDR_INLINE(xdrs, len) \
(*(xdrs)->x_ops->x_inline)(xdrs, len)
#define xdr_inline(xdrs, len) \
(*(xdrs)->x_ops->x_inline)(xdrs, len)
#define XDR_DESTROY(xdrs) \
do { \
if ((xdrs)->x_ops->x_destroy) \
(*(xdrs)->x_ops->x_destroy)(xdrs); \
} while (0)
#define xdr_destroy(xdrs) \
do { \
if ((xdrs)->x_ops->x_destroy) \
(*(xdrs)->x_ops->x_destroy)(xdrs); \
} while (0)
/*
* Solaris strips the '_t' from these types -- not sure why.
* But, let's be compatible.
*/
#define xdr_rpcvers(xdrs, versp) xdr_u_int32(xdrs, versp)
#define xdr_rpcprog(xdrs, progp) xdr_u_int32(xdrs, progp)
#define xdr_rpcproc(xdrs, procp) xdr_u_int32(xdrs, procp)
#define xdr_rpcprot(xdrs, protp) xdr_u_int32(xdrs, protp)
#define xdr_rpcport(xdrs, portp) xdr_u_int32(xdrs, portp)
/*
* Support struct for discriminated unions.
* You create an array of xdrdiscrim structures, terminated with
* an entry with a null procedure pointer. The xdr_union routine gets
* the discriminant value and then searches the array of structures
* for a matching value. If a match is found the associated xdr routine
* is called to handle that part of the union. If there is
* no match, then a default routine may be called.
* If there is no match and no default routine it is an error.
*/
#define NULL_xdrproc_t ((xdrproc_t)0)
struct xdr_discrim
{
int value;
xdrproc_t proc;
};
/*
* In-line routines for fast encode/decode of primitive data types.
* Caveat emptor: these use single memory cycles to get the
* data from the underlying buffer, and will fail to operate
* properly if the data is not aligned. The standard way to use these
* is to say:
* if ((buf = XDR_INLINE(xdrs, count)) == NULL)
* return (FALSE);
* <<< macro calls >>>
* where ``count'' is the number of bytes of data occupied
* by the primitive data types.
*
* N.B. and frozen for all time: each data type here uses 4 bytes
* of external representation.
*/
#define IXDR_GET_INT32(buf) ((int32_t)ntohl((u_int32_t)*(buf)++))
#define IXDR_PUT_INT32(buf, v) (*(buf)++ =(int32_t)htonl((u_int32_t)v))
#define IXDR_GET_U_INT32(buf) ((uint32_t)IXDR_GET_INT32(buf))
#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_INT32((buf), ((int32_t)(v)))
/* Warning: inline long routines are broken for 64 bit platforms.
* Because the other inline routines below are implemented in terms
* of them, they are all also broken for 64 bit platforms.
*/
#define IXDR_GET_LONG(buf) ((long)ntohl((u_int32_t)*(buf)++))
#define IXDR_PUT_LONG(buf, v) (*(buf)++ =(int32_t)htonl((u_int32_t)v))
#define IXDR_GET_U_LONG(buf) ((u_long)IXDR_GET_LONG(buf))
#define IXDR_PUT_U_LONG(buf, v) IXDR_PUT_LONG((buf), (v))
#define IXDR_GET_BOOL(buf) ((bool_t)IXDR_GET_LONG(buf))
#define IXDR_GET_ENUM(buf, t) ((t)IXDR_GET_LONG(buf))
#define IXDR_GET_SHORT(buf) ((short)IXDR_GET_LONG(buf))
#define IXDR_GET_U_SHORT(buf) ((u_short)IXDR_GET_LONG(buf))
#define IXDR_PUT_BOOL(buf, v) IXDR_PUT_LONG((buf), (v))
#define IXDR_PUT_ENUM(buf, v) IXDR_PUT_LONG((buf), (v))
#define IXDR_PUT_SHORT(buf, v) IXDR_PUT_LONG((buf), (v))
#define IXDR_PUT_U_SHORT(buf, v) IXDR_PUT_LONG((buf), (v))
/*
* These are the "generic" xdr routines.
*/
extern bool_t _EXFUN (xdr_void, (void));
extern bool_t _EXFUN (xdr_short, (XDR *, short *));
extern bool_t _EXFUN (xdr_u_short, (XDR *, u_short *));
extern bool_t _EXFUN (xdr_int, (XDR *, int *));
extern bool_t _EXFUN (xdr_u_int, (XDR *, u_int *));
extern bool_t _EXFUN (xdr_long, (XDR *, long *));
extern bool_t _EXFUN (xdr_u_long, (XDR *, u_long *));
extern bool_t _EXFUN (xdr_int8_t, (XDR *, int8_t *));
extern bool_t _EXFUN (xdr_uint8_t, (XDR *, uint8_t *));
extern bool_t _EXFUN (xdr_u_int8_t, (XDR *, u_int8_t *));
extern bool_t _EXFUN (xdr_int16_t, (XDR *, int16_t *));
extern bool_t _EXFUN (xdr_uint16_t, (XDR *, uint16_t *));
extern bool_t _EXFUN (xdr_u_int16_t, (XDR *, u_int16_t *));
extern bool_t _EXFUN (xdr_int32_t, (XDR *, int32_t *));
extern bool_t _EXFUN (xdr_uint32_t, (XDR *, uint32_t *));
extern bool_t _EXFUN (xdr_u_int32_t, (XDR *, u_int32_t *));
#if defined(___int64_t_defined)
extern bool_t _EXFUN (xdr_int64_t, (XDR *, int64_t *));
extern bool_t _EXFUN (xdr_uint64_t, (XDR *, uint64_t *));
extern bool_t _EXFUN (xdr_u_int64_t, (XDR *, u_int64_t *));
#endif /* ___int64_t_defined */
extern bool_t _EXFUN (xdr_bool, (XDR *, bool_t *));
extern bool_t _EXFUN (xdr_enum, (XDR *, enum_t *));
extern bool_t _EXFUN (xdr_array, (XDR *, char **, u_int *, u_int, u_int, xdrproc_t));
extern bool_t _EXFUN (xdr_bytes, (XDR *, char **, u_int *, u_int));
extern bool_t _EXFUN (xdr_opaque, (XDR *, char *, u_int));
extern bool_t _EXFUN (xdr_string, (XDR *, char **, u_int));
extern bool_t _EXFUN (xdr_union, (XDR *, enum_t *, char *,
_CONST struct xdr_discrim *, xdrproc_t));
extern bool_t _EXFUN (xdr_char, (XDR *, char *));
extern bool_t _EXFUN (xdr_u_char, (XDR *, u_char *));
extern bool_t _EXFUN (xdr_vector, (XDR *, char *, u_int, u_int, xdrproc_t));
extern bool_t _EXFUN (xdr_float, (XDR *, float *));
extern bool_t _EXFUN (xdr_double, (XDR *, double *));
/* extern bool_t _EXFUN (xdr_quadruple, (XDR *, long double *)); */
extern bool_t _EXFUN (xdr_reference, (XDR *, char **, u_int, xdrproc_t));
extern bool_t _EXFUN (xdr_pointer, (XDR *, char **, u_int, xdrproc_t));
extern bool_t _EXFUN (xdr_wrapstring, (XDR *, char **));
#if defined(___int64_t_defined)
extern bool_t _EXFUN (xdr_hyper, (XDR *, quad_t *));
extern bool_t _EXFUN (xdr_u_hyper, (XDR *, u_quad_t *));
extern bool_t _EXFUN (xdr_longlong_t, (XDR *, quad_t *));
extern bool_t _EXFUN (xdr_u_longlong_t, (XDR *, u_quad_t *));
#endif /* ___int64_t_defined */
extern u_long _EXFUN (xdr_sizeof, (xdrproc_t, void *));
/*
* Common opaque bytes objects used by many rpc protocols;
* declared here due to commonality.
*/
#define MAX_NETOBJ_SZ 1024
struct netobj
{
u_int n_len;
char *n_bytes;
};
typedef struct netobj netobj;
extern bool_t _EXFUN (xdr_netobj, (XDR *, struct netobj *));
/*
* These are the public routines for the various implementations of
* xdr streams.
*/
/* XDR using memory buffers */
extern void _EXFUN (xdrmem_create, (XDR *, char *, u_int, enum xdr_op));
/* XDR using stdio library */
#if defined(_STDIO_H_)
extern void _EXFUN (xdrstdio_create, (XDR *, FILE *, enum xdr_op));
#endif
/* XDR pseudo records for tcp */
extern void _EXFUN (xdrrec_create, (XDR *, u_int, u_int, void *,
int _EXPARM (, (void *, void *, int)),
int _EXPARM (, (void *, void *, int))));
/* make end of xdr record */
extern bool_t _EXFUN (xdrrec_endofrecord, (XDR *, bool_t));
/* move to beginning of next record */
extern bool_t _EXFUN (xdrrec_skiprecord, (XDR *));
/* true if no more input */
extern bool_t _EXFUN (xdrrec_eof, (XDR *));
extern u_int _EXFUN (xdrrec_readbytes, (XDR *, caddr_t, u_int));
/* free memory buffers for xdr */
extern void _EXFUN (xdr_free, (xdrproc_t, void *));
#ifdef __cplusplus
}
#endif
#endif /* !_RPC_XDR_H */

97
programs/develop/libraries/newlib/include/sched.h Normal file
View File

@ -0,0 +1,97 @@
/*
* Written by Joel Sherrill <joel@OARcorp.com>.
*
* COPYRIGHT (c) 1989-2010.
* On-Line Applications Research Corporation (OAR).
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION
* OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
* SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
* $Id: sched.h,v 1.2 2010/04/01 18:33:33 jjohnstn Exp $
*/
#ifndef _SCHED_H_
#define _SCHED_H_
#include <sys/types.h>
#include <sys/sched.h>
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_POSIX_PRIORITY_SCHEDULING)
/*
* XBD 13 - Set Scheduling Parameters, P1003.1b-2008, p. 1803
*/
int sched_setparam(
pid_t __pid,
const struct sched_param *__param
);
/*
* XBD 13 - Set Scheduling Parameters, P1003.1b-2008, p. 1800
*/
int sched_getparam(
pid_t __pid,
struct sched_param *__param
);
/*
* XBD 13 - Set Scheduling Policy and Scheduling Parameters,
* P1003.1b-2008, p. 1805
*/
int sched_setscheduler(
pid_t __pid,
int __policy,
const struct sched_param *__param
);
/*
* XBD 13 - Get Scheduling Policy, P1003.1b-2008, p. 1801
*/
int sched_getscheduler(
pid_t __pid
);
/*
* XBD 13 - Get Scheduling Parameter Limits, P1003.1b-2008, p. 1799
*/
int sched_get_priority_max(
int __policy
);
int sched_get_priority_min(
int __policy
);
/*
* XBD 13 - Get Scheduling Parameter Limits, P1003.1b-2008, p. 1802
*/
int sched_rr_get_interval(
pid_t __pid,
struct timespec *__interval
);
#endif /* _POSIX_PRIORITY_SCHEDULING */
#if defined(_POSIX_THREADS) || defined(_POSIX_PRIORITY_SCHEDULING)
/*
* XBD 13 - Yield Processor, P1003.1b-2008, p. 1807
*/
int sched_yield( void );
#endif /* _POSIX_THREADS or _POSIX_PRIORITY_SCHEDULING */
#ifdef __cplusplus
}
#endif
#endif /* _SCHED_H_ */

59
programs/develop/libraries/newlib/include/search.h Normal file
View File

@ -0,0 +1,59 @@
/* $NetBSD: search.h,v 1.12 1999/02/22 10:34:28 christos Exp $ */
/* $FreeBSD: src/include/search.h,v 1.4 2002/03/23 17:24:53 imp Exp $ */
/*
* Written by J.T. Conklin <jtc@netbsd.org>
* Public domain.
*/
#ifndef _SEARCH_H_
#define _SEARCH_H_
#include <sys/cdefs.h>
#include <machine/ansi.h>
#include <sys/types.h>
typedef struct entry {
char *key;
void *data;
} ENTRY;
typedef enum {
FIND, ENTER
} ACTION;
typedef enum {
preorder,
postorder,
endorder,
leaf
} VISIT;
#ifdef _SEARCH_PRIVATE
typedef struct node {
char *key;
struct node *llink, *rlink;
} node_t;
#endif
struct hsearch_data
{
struct internal_head *htable;
size_t htablesize;
};
__BEGIN_DECLS
int hcreate(size_t);
void hdestroy(void);
ENTRY *hsearch(ENTRY, ACTION);
int hcreate_r(size_t, struct hsearch_data *);
void hdestroy_r(struct hsearch_data *);
int hsearch_r(ENTRY, ACTION, ENTRY **, struct hsearch_data *);
void *tdelete(const void *, void **, int (*)(const void *, const void *));
void tdestroy (void *, void (*)(void *));
void *tfind(const void *, void **, int (*)(const void *, const void *));
void *tsearch(const void *, void **, int (*)(const void *, const void *));
void twalk(const void *, void (*)(const void *, VISIT, int));
__END_DECLS
#endif /* !_SEARCH_H_ */

20
programs/develop/libraries/newlib/include/setjmp.h Normal file
View File

@ -0,0 +1,20 @@
/*
setjmp.h
stubs for future use.
*/
#ifndef _SETJMP_H_
#define _SETJMP_H_
#include "_ansi.h"
#include <machine/setjmp.h>
_BEGIN_STD_C
void _EXFUN(longjmp,(jmp_buf __jmpb, int __retval));
int _EXFUN(setjmp,(jmp_buf __jmpb));
_END_STD_C
#endif /* _SETJMP_H_ */

30
programs/develop/libraries/newlib/include/signal.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef _SIGNAL_H_
#define _SIGNAL_H_
#include "_ansi.h"
#include <sys/signal.h>
_BEGIN_STD_C
typedef int sig_atomic_t; /* Atomic entity type (ANSI) */
#ifndef _POSIX_SOURCE
typedef _sig_func_ptr sighandler_t; /* glibc naming */
#endif /* !_POSIX_SOURCE */
#define SIG_DFL ((_sig_func_ptr)0) /* Default action */
#define SIG_IGN ((_sig_func_ptr)1) /* Ignore action */
#define SIG_ERR ((_sig_func_ptr)-1) /* Error return */
struct _reent;
_sig_func_ptr _EXFUN(_signal_r, (struct _reent *, int, _sig_func_ptr));
int _EXFUN(_raise_r, (struct _reent *, int));
#ifndef _REENT_ONLY
_sig_func_ptr _EXFUN(signal, (int, _sig_func_ptr));
int _EXFUN(raise, (int));
#endif
_END_STD_C
#endif /* _SIGNAL_H_ */

497
programs/develop/libraries/newlib/include/stdint.h Normal file
View File

@ -0,0 +1,497 @@
/*
* Copyright (c) 2004, 2005 by
* Ralf Corsepius, Ulm/Germany. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software
* is freely granted, provided that this notice is preserved.
*/
#ifndef _STDINT_H
#define _STDINT_H
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__GNUC__) && \
( (__GNUC__ >= 4) || \
( (__GNUC__ >= 3) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ > 2) ) )
/* gcc > 3.2 implicitly defines the values we are interested */
#define __STDINT_EXP(x) __##x##__
#else
#define __STDINT_EXP(x) x
#include <limits.h>
#endif
/* Check if "long long" is 64bit wide */
/* Modern GCCs provide __LONG_LONG_MAX__, SUSv3 wants LLONG_MAX */
#if ( defined(__LONG_LONG_MAX__) && (__LONG_LONG_MAX__ > 0x7fffffff) ) \
|| ( defined(LLONG_MAX) && (LLONG_MAX > 0x7fffffff) )
#define __have_longlong64 1
#endif
/* Check if "long" is 64bit or 32bit wide */
#if __STDINT_EXP(LONG_MAX) > 0x7fffffff
#define __have_long64 1
#elif __STDINT_EXP(LONG_MAX) == 0x7fffffff && !defined(__SPU__)
#define __have_long32 1
#define __have_long64 0
#endif
#if __STDINT_EXP(SCHAR_MAX) == 0x7f
typedef signed char int8_t ;
typedef unsigned char uint8_t ;
#define __int8_t_defined 1
#endif
#if __int8_t_defined
typedef signed char int_least8_t;
typedef unsigned char uint_least8_t;
#define __int_least8_t_defined 1
#endif
#if __STDINT_EXP(SHRT_MAX) == 0x7fff
typedef signed short int16_t;
typedef unsigned short uint16_t;
#define __int16_t_defined 1
#elif __STDINT_EXP(INT_MAX) == 0x7fff
typedef signed int int16_t;
typedef unsigned int uint16_t;
#define __int16_t_defined 1
#elif __STDINT_EXP(SCHAR_MAX) == 0x7fff
typedef signed char int16_t;
typedef unsigned char uint16_t;
#define __int16_t_defined 1
#endif
#if __int16_t_defined
typedef int16_t int_least16_t;
typedef uint16_t uint_least16_t;
#define __int_least16_t_defined 1
#if !__int_least8_t_defined
typedef int16_t int_least8_t;
typedef uint16_t uint_least8_t;
#define __int_least8_t_defined 1
#endif
#endif
#if __have_long32
typedef signed long int32_t;
typedef unsigned long uint32_t;
#define __int32_t_defined 1
#elif __STDINT_EXP(INT_MAX) == 0x7fffffffL
typedef signed int int32_t;
typedef unsigned int uint32_t;
#define __int32_t_defined 1
#elif __STDINT_EXP(SHRT_MAX) == 0x7fffffffL
typedef signed short int32_t;
typedef unsigned short uint32_t;
#define __int32_t_defined 1
#elif __STDINT_EXP(SCHAR_MAX) == 0x7fffffffL
typedef signed char int32_t;
typedef unsigned char uint32_t;
#define __int32_t_defined 1
#endif
#if __int32_t_defined
typedef int32_t int_least32_t;
typedef uint32_t uint_least32_t;
#define __int_least32_t_defined 1
#if !__int_least8_t_defined
typedef int32_t int_least8_t;
typedef uint32_t uint_least8_t;
#define __int_least8_t_defined 1
#endif
#if !__int_least16_t_defined
typedef int32_t int_least16_t;
typedef uint32_t uint_least16_t;
#define __int_least16_t_defined 1
#endif
#endif
#if __have_long64
typedef signed long int64_t;
typedef unsigned long uint64_t;
#define __int64_t_defined 1
#elif __have_longlong64
typedef signed long long int64_t;
typedef unsigned long long uint64_t;
#define __int64_t_defined 1
#elif __STDINT_EXP(INT_MAX) > 0x7fffffff
typedef signed int int64_t;
typedef unsigned int uint64_t;
#define __int64_t_defined 1
#endif
#if __int64_t_defined
typedef int64_t int_least64_t;
typedef uint64_t uint_least64_t;
#define __int_least64_t_defined 1
#if !__int_least8_t_defined
typedef int64_t int_least8_t;
typedef uint64_t uint_least8_t;
#define __int_least8_t_defined 1
#endif
#if !__int_least16_t_defined
typedef int64_t int_least16_t;
typedef uint64_t uint_least16_t;
#define __int_least16_t_defined 1
#endif
#if !__int_least32_t_defined
typedef int64_t int_least32_t;
typedef uint64_t uint_least32_t;
#define __int_least32_t_defined 1
#endif
#endif
/*
* Fastest minimum-width integer types
*
* Assume int to be the fastest type for all types with a width
* less than __INT_MAX__ rsp. INT_MAX
*/
#if __STDINT_EXP(INT_MAX) >= 0x7f
typedef signed int int_fast8_t;
typedef unsigned int uint_fast8_t;
#define __int_fast8_t_defined 1
#endif
#if __STDINT_EXP(INT_MAX) >= 0x7fff
typedef signed int int_fast16_t;
typedef unsigned int uint_fast16_t;
#define __int_fast16_t_defined 1
#endif
#if __STDINT_EXP(INT_MAX) >= 0x7fffffff
typedef signed int int_fast32_t;
typedef unsigned int uint_fast32_t;
#define __int_fast32_t_defined 1
#endif
#if __STDINT_EXP(INT_MAX) > 0x7fffffff
typedef signed int int_fast64_t;
typedef unsigned int uint_fast64_t;
#define __int_fast64_t_defined 1
#else
#define __int_fast64_t_defined 0
#endif
/*
* Fall back to [u]int_least<N>_t for [u]int_fast<N>_t types
* not having been defined, yet.
* Leave undefined, if [u]int_least<N>_t should not be available.
*/
#if !__int_fast8_t_defined
#if __int_least8_t_defined
typedef int_least8_t int_fast8_t;
typedef uint_least8_t uint_fast8_t;
#define __int_fast8_t_defined 1
#endif
#endif
#if !__int_fast16_t_defined
#if __int_least16_t_defined
typedef int_least16_t int_fast16_t;
typedef uint_least16_t uint_fast16_t;
#define __int_fast16_t_defined 1
#endif
#endif
#if !__int_fast32_t_defined
#if __int_least32_t_defined
typedef int_least32_t int_fast32_t;
typedef uint_least32_t uint_fast32_t;
#define __int_fast32_t_defined 1
#endif
#endif
#if !__int_fast64_t_defined
#if __int_least64_t_defined
typedef int_least64_t int_fast64_t;
typedef uint_least64_t uint_fast64_t;
#undef __int_fast64_t_defined
#define __int_fast64_t_defined 1
#endif
#endif
/* Greatest-width integer types */
/* Modern GCCs provide __INTMAX_TYPE__ */
#if defined(__INTMAX_TYPE__)
typedef __INTMAX_TYPE__ intmax_t;
#elif __have_longlong64
typedef signed long long intmax_t;
#else
typedef signed long intmax_t;
#endif
/* Modern GCCs provide __UINTMAX_TYPE__ */
#if defined(__UINTMAX_TYPE__)
typedef __UINTMAX_TYPE__ uintmax_t;
#elif __have_longlong64
typedef unsigned long long uintmax_t;
#else
typedef unsigned long uintmax_t;
#endif
/*
* GCC doesn't provide an appropriate macro for [u]intptr_t
* For now, use __PTRDIFF_TYPE__
*/
#if defined(__PTRDIFF_TYPE__)
typedef signed __PTRDIFF_TYPE__ intptr_t;
typedef unsigned __PTRDIFF_TYPE__ uintptr_t;
#define INTPTR_MAX PTRDIFF_MAX
#define INTPTR_MIN PTRDIFF_MIN
#ifdef __UINTPTR_MAX__
#define UINTPTR_MAX __UINTPTR_MAX__
#else
#define UINTPTR_MAX (2UL * PTRDIFF_MAX + 1)
#endif
#else
/*
* Fallback to hardcoded values,
* should be valid on cpu's with 32bit int/32bit void*
*/
typedef signed long intptr_t;
typedef unsigned long uintptr_t;
#define INTPTR_MAX __STDINT_EXP(LONG_MAX)
#define INTPTR_MIN (-__STDINT_EXP(LONG_MAX) - 1)
#define UINTPTR_MAX (__STDINT_EXP(LONG_MAX) * 2UL + 1)
#endif
/* Limits of Specified-Width Integer Types */
#if __int8_t_defined
#define INT8_MIN -128
#define INT8_MAX 127
#define UINT8_MAX 255
#endif
#if __int_least8_t_defined
#define INT_LEAST8_MIN -128
#define INT_LEAST8_MAX 127
#define UINT_LEAST8_MAX 255
#else
#error required type int_least8_t missing
#endif
#if __int16_t_defined
#define INT16_MIN -32768
#define INT16_MAX 32767
#define UINT16_MAX 65535
#endif
#if __int_least16_t_defined
#define INT_LEAST16_MIN -32768
#define INT_LEAST16_MAX 32767
#define UINT_LEAST16_MAX 65535
#else
#error required type int_least16_t missing
#endif
#if __int32_t_defined
#if __have_long32
#define INT32_MIN (-2147483647L-1)
#define INT32_MAX 2147483647L
#define UINT32_MAX 4294967295UL
#else
#define INT32_MIN (-2147483647-1)
#define INT32_MAX 2147483647
#define UINT32_MAX 4294967295U
#endif
#endif
#if __int_least32_t_defined
#if __have_long32
#define INT_LEAST32_MIN (-2147483647L-1)
#define INT_LEAST32_MAX 2147483647L
#define UINT_LEAST32_MAX 4294967295UL
#else
#define INT_LEAST32_MIN (-2147483647-1)
#define INT_LEAST32_MAX 2147483647
#define UINT_LEAST32_MAX 4294967295U
#endif
#else
#error required type int_least32_t missing
#endif
#if __int64_t_defined
#if __have_long64
#define INT64_MIN (-9223372036854775807L-1L)
#define INT64_MAX 9223372036854775807L
#define UINT64_MAX 18446744073709551615U
#elif __have_longlong64
#define INT64_MIN (-9223372036854775807LL-1LL)
#define INT64_MAX 9223372036854775807LL
#define UINT64_MAX 18446744073709551615ULL
#endif
#endif
#if __int_least64_t_defined
#if __have_long64
#define INT_LEAST64_MIN (-9223372036854775807L-1L)
#define INT_LEAST64_MAX 9223372036854775807L
#define UINT_LEAST64_MAX 18446744073709551615U
#elif __have_longlong64
#define INT_LEAST64_MIN (-9223372036854775807LL-1LL)
#define INT_LEAST64_MAX 9223372036854775807LL
#define UINT_LEAST64_MAX 18446744073709551615ULL
#endif
#endif
#if __int_fast8_t_defined
#if __STDINT_EXP(INT_MAX) >= 0x7f
#define INT_FAST8_MIN (-__STDINT_EXP(INT_MAX)-1)
#define INT_FAST8_MAX __STDINT_EXP(INT_MAX)
#define UINT_FAST8_MAX (__STDINT_EXP(INT_MAX)*2U+1U)
#else
#define INT_FAST8_MIN INT_LEAST8_MIN
#define INT_FAST8_MAX INT_LEAST8_MAX
#define UINT_FAST8_MAX UINT_LEAST8_MAX
#endif
#endif
#if __int_fast16_t_defined
#if __STDINT_EXP(INT_MAX) >= 0x7fff
#define INT_FAST16_MIN (-__STDINT_EXP(INT_MAX)-1)
#define INT_FAST16_MAX __STDINT_EXP(INT_MAX)
#define UINT_FAST16_MAX (__STDINT_EXP(INT_MAX)*2U+1U)
#else
#define INT_FAST16_MIN INT_LEAST16_MIN
#define INT_FAST16_MAX INT_LEAST16_MAX
#define UINT_FAST16_MAX UINT_LEAST16_MAX
#endif
#endif
#if __int_fast32_t_defined
#if __STDINT_EXP(INT_MAX) >= 0x7fffffff
#define INT_FAST32_MIN (-__STDINT_EXP(INT_MAX)-1)
#define INT_FAST32_MAX __STDINT_EXP(INT_MAX)
#define UINT_FAST32_MAX (__STDINT_EXP(INT_MAX)*2U+1U)
#else
#define INT_FAST32_MIN INT_LEAST32_MIN
#define INT_FAST32_MAX INT_LEAST32_MAX
#define UINT_FAST32_MAX UINT_LEAST32_MAX
#endif
#endif
#if __int_fast64_t_defined
#if __STDINT_EXP(INT_MAX) > 0x7fffffff
#define INT_FAST64_MIN (-__STDINT_EXP(INT_MAX)-1)
#define INT_FAST64_MAX __STDINT_EXP(INT_MAX)
#define UINT_FAST64_MAX (__STDINT_EXP(INT_MAX)*2U+1U)
#else
#define INT_FAST64_MIN INT_LEAST64_MIN
#define INT_FAST64_MAX INT_LEAST64_MAX
#define UINT_FAST64_MAX UINT_LEAST64_MAX
#endif
#endif
#ifdef __INTMAX_MAX__
#define INTMAX_MAX __INTMAX_MAX__
#define INTMAX_MIN (-INTMAX_MAX - 1)
#elif defined(__INTMAX_TYPE__)
/* All relevant GCC versions prefer long to long long for intmax_t. */
#define INTMAX_MAX INT64_MAX
#define INTMAX_MIN INT64_MIN
#endif
#ifdef __UINTMAX_MAX__
#define UINTMAX_MAX __UINTMAX_MAX__
#elif defined(__UINTMAX_TYPE__)
/* All relevant GCC versions prefer long to long long for intmax_t. */
#define UINTMAX_MAX UINT64_MAX
#endif
/* This must match size_t in stddef.h, currently long unsigned int */
#ifdef __SIZE_MAX__
#define SIZE_MAX __SIZE_MAX__
#else
#define SIZE_MAX (__STDINT_EXP(LONG_MAX) * 2UL + 1)
#endif
/* This must match sig_atomic_t in <signal.h> (currently int) */
#define SIG_ATOMIC_MIN (-__STDINT_EXP(INT_MAX) - 1)
#define SIG_ATOMIC_MAX __STDINT_EXP(INT_MAX)
/* This must match ptrdiff_t in <stddef.h> (currently long int) */
#ifdef __PTRDIFF_MAX__
#define PTRDIFF_MAX __PTRDIFF_MAX__
#else
#define PTRDIFF_MAX __STDINT_EXP(LONG_MAX)
#endif
#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
#ifdef __WCHAR_MAX__
#define WCHAR_MAX __WCHAR_MAX__
#endif
#ifdef __WCHAR_MIN__
#define WCHAR_MIN __WCHAR_MIN__
#endif
/* wint_t is unsigned int on almost all GCC targets. */
#ifdef __WINT_MAX__
#define WINT_MAX __WINT_MAX__
#else
#define WINT_MAX (__STDINT_EXP(INT_MAX) * 2U + 1U)
#endif
#ifdef __WINT_MIN__
#define WINT_MIN __WINT_MIN__
#else
#define WINT_MIN 0U
#endif
/** Macros for minimum-width integer constant expressions */
#define INT8_C(x) x
#if __STDINT_EXP(INT_MAX) > 0x7f
#define UINT8_C(x) x
#else
#define UINT8_C(x) x##U
#endif
#define INT16_C(x) x
#if __STDINT_EXP(INT_MAX) > 0x7fff
#define UINT16_C(x) x
#else
#define UINT16_C(x) x##U
#endif
#if __have_long32
#define INT32_C(x) x##L
#define UINT32_C(x) x##UL
#else
#define INT32_C(x) x
#define UINT32_C(x) x##U
#endif
#if __int64_t_defined
#if __have_long64
#define INT64_C(x) x##L
#define UINT64_C(x) x##UL
#else
#define INT64_C(x) x##LL
#define UINT64_C(x) x##ULL
#endif
#endif
/** Macros for greatest-width integer constant expression */
#if __have_long64
#define INTMAX_C(x) x##L
#define UINTMAX_C(x) x##UL
#else
#define INTMAX_C(x) x##LL
#define UINTMAX_C(x) x##ULL
#endif
#ifdef __cplusplus
}
#endif
#endif /* _STDINT_H */

685
programs/develop/libraries/newlib/include/stdio.h Normal file
View File

@ -0,0 +1,685 @@
/*
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* @(#)stdio.h 5.3 (Berkeley) 3/15/86
*/
/*
* NB: to fit things in six character monocase externals, the
* stdio code uses the prefix `__s' for stdio objects, typically
* followed by a three-character attempt at a mnemonic.
*/
#ifndef _STDIO_H_
#define _STDIO_H_
#include "_ansi.h"
#define _FSTDIO /* ``function stdio'' */
#define __need_size_t
#include <stddef.h>
#define __need___va_list
#include <stdarg.h>
/*
* <sys/reent.h> defines __FILE, _fpos_t.
* They must be defined there because struct _reent needs them (and we don't
* want reent.h to include this file.
*/
#include <sys/reent.h>
#include <sys/types.h>
_BEGIN_STD_C
typedef __FILE FILE;
#ifdef __CYGWIN__
typedef _fpos64_t fpos_t;
#else
typedef _fpos_t fpos_t;
#ifdef __LARGE64_FILES
typedef _fpos64_t fpos64_t;
#endif
#endif /* !__CYGWIN__ */
#include <sys/stdio.h>
#define __SLBF 0x0001 /* line buffered */
#define __SNBF 0x0002 /* unbuffered */
#define __SRD 0x0004 /* OK to read */
#define __SWR 0x0008 /* OK to write */
/* RD and WR are never simultaneously asserted */
#define __SRW 0x0010 /* open for reading & writing */
#define __SEOF 0x0020 /* found EOF */
#define __SERR 0x0040 /* found error */
#define __SMBF 0x0080 /* _buf is from malloc */
#define __SAPP 0x0100 /* fdopen()ed in append mode - so must write to end */
#define __SSTR 0x0200 /* this is an sprintf/snprintf string */
#define __SOPT 0x0400 /* do fseek() optimisation */
#define __SNPT 0x0800 /* do not do fseek() optimisation */
#define __SOFF 0x1000 /* set iff _offset is in fact correct */
#define __SORD 0x2000 /* true => stream orientation (byte/wide) decided */
#if defined(__CYGWIN__)
# define __SCLE 0x4000 /* convert line endings CR/LF <-> NL */
#endif
#define __SL64 0x8000 /* is 64-bit offset large file */
/* _flags2 flags */
#define __SWID 0x2000 /* true => stream orientation wide, false => byte, only valid if __SORD in _flags is true */
/*
* The following three definitions are for ANSI C, which took them
* from System V, which stupidly took internal interface macros and
* made them official arguments to setvbuf(), without renaming them.
* Hence, these ugly _IOxxx names are *supposed* to appear in user code.
*
* Although these happen to match their counterparts above, the
* implementation does not rely on that (so these could be renumbered).
*/
#define _IOFBF 0 /* setvbuf should set fully buffered */
#define _IOLBF 1 /* setvbuf should set line buffered */
#define _IONBF 2 /* setvbuf should set unbuffered */
#ifndef NULL
#define NULL 0
#endif
#define EOF (-1)
#ifdef __BUFSIZ__
#define BUFSIZ __BUFSIZ__
#else
#define BUFSIZ 1024
#endif
#ifdef __FOPEN_MAX__
#define FOPEN_MAX __FOPEN_MAX__
#else
#define FOPEN_MAX 20
#endif
#ifdef __FILENAME_MAX__
#define FILENAME_MAX __FILENAME_MAX__
#else
#define FILENAME_MAX 1024
#endif
#ifdef __L_tmpnam__
#define L_tmpnam __L_tmpnam__
#else
#define L_tmpnam FILENAME_MAX
#endif
#ifndef __STRICT_ANSI__
#define P_tmpdir "/tmp"
#endif
#ifndef SEEK_SET
#define SEEK_SET 0 /* set file offset to offset */
#endif
#ifndef SEEK_CUR
#define SEEK_CUR 1 /* set file offset to current plus offset */
#endif
#ifndef SEEK_END
#define SEEK_END 2 /* set file offset to EOF plus offset */
#endif
#define TMP_MAX 26
#ifndef _REENT_ONLY
#define stdin (_REENT->_stdin)
#define stdout (_REENT->_stdout)
#define stderr (_REENT->_stderr)
#else /* _REENT_ONLY */
#define stdin (_impure_ptr->_stdin)
#define stdout (_impure_ptr->_stdout)
#define stderr (_impure_ptr->_stderr)
#endif /* _REENT_ONLY */
#define _stdin_r(x) ((x)->_stdin)
#define _stdout_r(x) ((x)->_stdout)
#define _stderr_r(x) ((x)->_stderr)
/*
* Functions defined in ANSI C standard.
*/
#ifndef __VALIST
#ifdef __GNUC__
#define __VALIST __gnuc_va_list
#else
#define __VALIST char*
#endif
#endif
FILE * _EXFUN(tmpfile, (void));
char * _EXFUN(tmpnam, (char *));
int _EXFUN(fclose, (FILE *));
int _EXFUN(fflush, (FILE *));
FILE * _EXFUN(freopen, (const char *, const char *, FILE *));
void _EXFUN(setbuf, (FILE *, char *));
int _EXFUN(setvbuf, (FILE *, char *, int, size_t));
int _EXFUN(fprintf, (FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(fscanf, (FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
int _EXFUN(printf, (const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 1, 2))));
int _EXFUN(scanf, (const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 1, 2))));
int _EXFUN(sscanf, (const char *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
int _EXFUN(vfprintf, (FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(vprintf, (const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 1, 0))));
int _EXFUN(vsprintf, (char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(fgetc, (FILE *));
char * _EXFUN(fgets, (char *, int, FILE *));
int _EXFUN(fputc, (int, FILE *));
int _EXFUN(fputs, (const char *, FILE *));
int _EXFUN(getc, (FILE *));
int _EXFUN(getchar, (void));
char * _EXFUN(gets, (char *));
int _EXFUN(putc, (int, FILE *));
int _EXFUN(putchar, (int));
int _EXFUN(puts, (const char *));
int _EXFUN(ungetc, (int, FILE *));
size_t _EXFUN(fread, (_PTR, size_t _size, size_t _n, FILE *));
size_t _EXFUN(fwrite, (const _PTR , size_t _size, size_t _n, FILE *));
#ifdef _COMPILING_NEWLIB
int _EXFUN(fgetpos, (FILE *, _fpos_t *));
#else
int _EXFUN(fgetpos, (FILE *, fpos_t *));
#endif
int _EXFUN(fseek, (FILE *, long, int));
#ifdef _COMPILING_NEWLIB
int _EXFUN(fsetpos, (FILE *, const _fpos_t *));
#else
int _EXFUN(fsetpos, (FILE *, const fpos_t *));
#endif
long _EXFUN(ftell, ( FILE *));
void _EXFUN(rewind, (FILE *));
void _EXFUN(clearerr, (FILE *));
int _EXFUN(feof, (FILE *));
int _EXFUN(ferror, (FILE *));
void _EXFUN(perror, (const char *));
#ifndef _REENT_ONLY
FILE * _EXFUN(fopen, (const char *_name, const char *_type));
int _EXFUN(sprintf, (char *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(remove, (const char *));
int _EXFUN(rename, (const char *, const char *));
#endif
#if !defined(__STRICT_ANSI__) || defined(__USE_XOPEN2K)
#ifdef _COMPILING_NEWLIB
int _EXFUN(fseeko, (FILE *, _off_t, int));
_off_t _EXFUN(ftello, ( FILE *));
#else
int _EXFUN(fseeko, (FILE *, off_t, int));
off_t _EXFUN(ftello, ( FILE *));
#endif
#endif
#if !defined(__STRICT_ANSI__) || (__STDC_VERSION__ >= 199901L)
#ifndef _REENT_ONLY
int _EXFUN(asiprintf, (char **, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
char * _EXFUN(asniprintf, (char *, size_t *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
char * _EXFUN(asnprintf, (char *, size_t *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(asprintf, (char **, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
#ifndef diprintf
int _EXFUN(diprintf, (int, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
#endif
int _EXFUN(fcloseall, (_VOID));
int _EXFUN(fiprintf, (FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(fiscanf, (FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
int _EXFUN(iprintf, (const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 1, 2))));
int _EXFUN(iscanf, (const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 1, 2))));
int _EXFUN(siprintf, (char *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(siscanf, (const char *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
int _EXFUN(snprintf, (char *, size_t, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(sniprintf, (char *, size_t, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
char * _EXFUN(tempnam, (const char *, const char *));
int _EXFUN(vasiprintf, (char **, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
char * _EXFUN(vasniprintf, (char *, size_t *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
char * _EXFUN(vasnprintf, (char *, size_t *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(vasprintf, (char **, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(vdiprintf, (int, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(vfiprintf, (FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(vfiscanf, (FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
int _EXFUN(vfscanf, (FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
int _EXFUN(viprintf, (const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 1, 0))));
int _EXFUN(viscanf, (const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 1, 0))));
int _EXFUN(vscanf, (const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 1, 0))));
int _EXFUN(vsiprintf, (char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(vsiscanf, (const char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
int _EXFUN(vsniprintf, (char *, size_t, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(vsnprintf, (char *, size_t, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(vsscanf, (const char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
#endif /* !_REENT_ONLY */
#endif /* !__STRICT_ANSI__ */
/*
* Routines in POSIX 1003.1:2001.
*/
#ifndef __STRICT_ANSI__
#ifndef _REENT_ONLY
FILE * _EXFUN(fdopen, (int, const char *));
#endif
int _EXFUN(fileno, (FILE *));
int _EXFUN(getw, (FILE *));
int _EXFUN(pclose, (FILE *));
FILE * _EXFUN(popen, (const char *, const char *));
int _EXFUN(putw, (int, FILE *));
void _EXFUN(setbuffer, (FILE *, char *, int));
int _EXFUN(setlinebuf, (FILE *));
int _EXFUN(getc_unlocked, (FILE *));
int _EXFUN(getchar_unlocked, (void));
void _EXFUN(flockfile, (FILE *));
int _EXFUN(ftrylockfile, (FILE *));
void _EXFUN(funlockfile, (FILE *));
int _EXFUN(putc_unlocked, (int, FILE *));
int _EXFUN(putchar_unlocked, (int));
#endif /* ! __STRICT_ANSI__ */
/*
* Routines in POSIX 1003.1:200x.
*/
#ifndef __STRICT_ANSI__
# ifndef _REENT_ONLY
# ifndef dprintf
int _EXFUN(dprintf, (int, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
# endif
FILE * _EXFUN(fmemopen, (void *, size_t, const char *));
/* getdelim - see __getdelim for now */
/* getline - see __getline for now */
FILE * _EXFUN(open_memstream, (char **, size_t *));
#if defined (__CYGWIN__)
int _EXFUN(renameat, (int, const char *, int, const char *));
#endif
int _EXFUN(vdprintf, (int, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
# endif
#endif
/*
* Recursive versions of the above.
*/
int _EXFUN(_asiprintf_r, (struct _reent *, char **, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
char * _EXFUN(_asniprintf_r, (struct _reent *, char *, size_t *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 4, 5))));
char * _EXFUN(_asnprintf_r, (struct _reent *, char *, size_t *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 4, 5))));
int _EXFUN(_asprintf_r, (struct _reent *, char **, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_diprintf_r, (struct _reent *, int, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_dprintf_r, (struct _reent *, int, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_fclose_r, (struct _reent *, FILE *));
int _EXFUN(_fcloseall_r, (struct _reent *));
FILE * _EXFUN(_fdopen_r, (struct _reent *, int, const char *));
int _EXFUN(_fflush_r, (struct _reent *, FILE *));
int _EXFUN(_fgetc_r, (struct _reent *, FILE *));
char * _EXFUN(_fgets_r, (struct _reent *, char *, int, FILE *));
#ifdef _COMPILING_NEWLIB
int _EXFUN(_fgetpos_r, (struct _reent *, FILE *, _fpos_t *));
int _EXFUN(_fsetpos_r, (struct _reent *, FILE *, const _fpos_t *));
#else
int _EXFUN(_fgetpos_r, (struct _reent *, FILE *, fpos_t *));
int _EXFUN(_fsetpos_r, (struct _reent *, FILE *, const fpos_t *));
#endif
int _EXFUN(_fiprintf_r, (struct _reent *, FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_fiscanf_r, (struct _reent *, FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 3, 4))));
FILE * _EXFUN(_fmemopen_r, (struct _reent *, void *, size_t, const char *));
FILE * _EXFUN(_fopen_r, (struct _reent *, const char *, const char *));
FILE * _EXFUN(_freopen_r, (struct _reent *, const char *, const char *, FILE *));
int _EXFUN(_fprintf_r, (struct _reent *, FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_fpurge_r, (struct _reent *, FILE *));
int _EXFUN(_fputc_r, (struct _reent *, int, FILE *));
int _EXFUN(_fputs_r, (struct _reent *, const char *, FILE *));
size_t _EXFUN(_fread_r, (struct _reent *, _PTR, size_t _size, size_t _n, FILE *));
int _EXFUN(_fscanf_r, (struct _reent *, FILE *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 3, 4))));
int _EXFUN(_fseek_r, (struct _reent *, FILE *, long, int));
int _EXFUN(_fseeko_r,(struct _reent *, FILE *, _off_t, int));
long _EXFUN(_ftell_r, (struct _reent *, FILE *));
_off_t _EXFUN(_ftello_r,(struct _reent *, FILE *));
void _EXFUN(_rewind_r, (struct _reent *, FILE *));
size_t _EXFUN(_fwrite_r, (struct _reent *, const _PTR , size_t _size, size_t _n, FILE *));
int _EXFUN(_getc_r, (struct _reent *, FILE *));
int _EXFUN(_getc_unlocked_r, (struct _reent *, FILE *));
int _EXFUN(_getchar_r, (struct _reent *));
int _EXFUN(_getchar_unlocked_r, (struct _reent *));
char * _EXFUN(_gets_r, (struct _reent *, char *));
int _EXFUN(_iprintf_r, (struct _reent *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(_iscanf_r, (struct _reent *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
FILE * _EXFUN(_open_memstream_r, (struct _reent *, char **, size_t *));
void _EXFUN(_perror_r, (struct _reent *, const char *));
int _EXFUN(_printf_r, (struct _reent *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 2, 3))));
int _EXFUN(_putc_r, (struct _reent *, int, FILE *));
int _EXFUN(_putc_unlocked_r, (struct _reent *, int, FILE *));
int _EXFUN(_putchar_unlocked_r, (struct _reent *, int));
int _EXFUN(_putchar_r, (struct _reent *, int));
int _EXFUN(_puts_r, (struct _reent *, const char *));
int _EXFUN(_remove_r, (struct _reent *, const char *));
int _EXFUN(_rename_r, (struct _reent *,
const char *_old, const char *_new));
int _EXFUN(_scanf_r, (struct _reent *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 2, 3))));
int _EXFUN(_siprintf_r, (struct _reent *, char *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_siscanf_r, (struct _reent *, const char *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 3, 4))));
int _EXFUN(_sniprintf_r, (struct _reent *, char *, size_t, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 4, 5))));
int _EXFUN(_snprintf_r, (struct _reent *, char *, size_t, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 4, 5))));
int _EXFUN(_sprintf_r, (struct _reent *, char *, const char *, ...)
_ATTRIBUTE ((__format__ (__printf__, 3, 4))));
int _EXFUN(_sscanf_r, (struct _reent *, const char *, const char *, ...)
_ATTRIBUTE ((__format__ (__scanf__, 3, 4))));
char * _EXFUN(_tempnam_r, (struct _reent *, const char *, const char *));
FILE * _EXFUN(_tmpfile_r, (struct _reent *));
char * _EXFUN(_tmpnam_r, (struct _reent *, char *));
int _EXFUN(_ungetc_r, (struct _reent *, int, FILE *));
int _EXFUN(_vasiprintf_r, (struct _reent *, char **, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
char * _EXFUN(_vasniprintf_r, (struct _reent*, char *, size_t *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 4, 0))));
char * _EXFUN(_vasnprintf_r, (struct _reent*, char *, size_t *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 4, 0))));
int _EXFUN(_vasprintf_r, (struct _reent *, char **, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vdiprintf_r, (struct _reent *, int, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vdprintf_r, (struct _reent *, int, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vfiprintf_r, (struct _reent *, FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vfiscanf_r, (struct _reent *, FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 3, 0))));
int _EXFUN(_vfprintf_r, (struct _reent *, FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vfscanf_r, (struct _reent *, FILE *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 3, 0))));
int _EXFUN(_viprintf_r, (struct _reent *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(_viscanf_r, (struct _reent *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
int _EXFUN(_vprintf_r, (struct _reent *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 2, 0))));
int _EXFUN(_vscanf_r, (struct _reent *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 2, 0))));
int _EXFUN(_vsiprintf_r, (struct _reent *, char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vsiscanf_r, (struct _reent *, const char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 3, 0))));
int _EXFUN(_vsniprintf_r, (struct _reent *, char *, size_t, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 4, 0))));
int _EXFUN(_vsnprintf_r, (struct _reent *, char *, size_t, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 4, 0))));
int _EXFUN(_vsprintf_r, (struct _reent *, char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__printf__, 3, 0))));
int _EXFUN(_vsscanf_r, (struct _reent *, const char *, const char *, __VALIST)
_ATTRIBUTE ((__format__ (__scanf__, 3, 0))));
/* Other extensions. */
int _EXFUN(fpurge, (FILE *));
ssize_t _EXFUN(__getdelim, (char **, size_t *, int, FILE *));
ssize_t _EXFUN(__getline, (char **, size_t *, FILE *));
#ifdef __LARGE64_FILES
#if !defined(__CYGWIN__) || defined(_COMPILING_NEWLIB)
FILE * _EXFUN(fdopen64, (int, const char *));
FILE * _EXFUN(fopen64, (const char *, const char *));
FILE * _EXFUN(freopen64, (_CONST char *, _CONST char *, FILE *));
_off64_t _EXFUN(ftello64, (FILE *));
_off64_t _EXFUN(fseeko64, (FILE *, _off64_t, int));
int _EXFUN(fgetpos64, (FILE *, _fpos64_t *));
int _EXFUN(fsetpos64, (FILE *, const _fpos64_t *));
FILE * _EXFUN(tmpfile64, (void));
FILE * _EXFUN(_fdopen64_r, (struct _reent *, int, const char *));
FILE * _EXFUN(_fopen64_r, (struct _reent *,const char *, const char *));
FILE * _EXFUN(_freopen64_r, (struct _reent *, _CONST char *, _CONST char *, FILE *));
_off64_t _EXFUN(_ftello64_r, (struct _reent *, FILE *));
_off64_t _EXFUN(_fseeko64_r, (struct _reent *, FILE *, _off64_t, int));
int _EXFUN(_fgetpos64_r, (struct _reent *, FILE *, _fpos64_t *));
int _EXFUN(_fsetpos64_r, (struct _reent *, FILE *, const _fpos64_t *));
FILE * _EXFUN(_tmpfile64_r, (struct _reent *));
#endif /* !__CYGWIN__ */
#endif /* __LARGE64_FILES */
/*
* Routines internal to the implementation.
*/
int _EXFUN(__srget_r, (struct _reent *, FILE *));
int _EXFUN(__swbuf_r, (struct _reent *, int, FILE *));
/*
* Stdio function-access interface.
*/
#ifndef __STRICT_ANSI__
# ifdef __LARGE64_FILES
FILE *_EXFUN(funopen,(const _PTR __cookie,
int (*__readfn)(_PTR __c, char *__buf, int __n),
int (*__writefn)(_PTR __c, const char *__buf, int __n),
_fpos64_t (*__seekfn)(_PTR __c, _fpos64_t __off, int __whence),
int (*__closefn)(_PTR __c)));
FILE *_EXFUN(_funopen_r,(struct _reent *, const _PTR __cookie,
int (*__readfn)(_PTR __c, char *__buf, int __n),
int (*__writefn)(_PTR __c, const char *__buf, int __n),
_fpos64_t (*__seekfn)(_PTR __c, _fpos64_t __off, int __whence),
int (*__closefn)(_PTR __c)));
# else
FILE *_EXFUN(funopen,(const _PTR __cookie,
int (*__readfn)(_PTR __cookie, char *__buf, int __n),
int (*__writefn)(_PTR __cookie, const char *__buf, int __n),
fpos_t (*__seekfn)(_PTR __cookie, fpos_t __off, int __whence),
int (*__closefn)(_PTR __cookie)));
FILE *_EXFUN(_funopen_r,(struct _reent *, const _PTR __cookie,
int (*__readfn)(_PTR __cookie, char *__buf, int __n),
int (*__writefn)(_PTR __cookie, const char *__buf, int __n),
fpos_t (*__seekfn)(_PTR __cookie, fpos_t __off, int __whence),
int (*__closefn)(_PTR __cookie)));
# endif /* !__LARGE64_FILES */
# define fropen(__cookie, __fn) funopen(__cookie, __fn, (int (*)())0, \
(fpos_t (*)())0, (int (*)())0)
# define fwopen(__cookie, __fn) funopen(__cookie, (int (*)())0, __fn, \
(fpos_t (*)())0, (int (*)())0)
typedef ssize_t cookie_read_function_t(void *__cookie, char *__buf, size_t __n);
typedef ssize_t cookie_write_function_t(void *__cookie, const char *__buf,
size_t __n);
# ifdef __LARGE64_FILES
typedef int cookie_seek_function_t(void *__cookie, _off64_t *__off,
int __whence);
# else
typedef int cookie_seek_function_t(void *__cookie, off_t *__off, int __whence);
# endif /* !__LARGE64_FILES */
typedef int cookie_close_function_t(void *__cookie);
typedef struct
{
/* These four struct member names are dictated by Linux; hopefully,
they don't conflict with any macros. */
cookie_read_function_t *read;
cookie_write_function_t *write;
cookie_seek_function_t *seek;
cookie_close_function_t *close;
} cookie_io_functions_t;
FILE *_EXFUN(fopencookie,(void *__cookie,
const char *__mode, cookie_io_functions_t __functions));
FILE *_EXFUN(_fopencookie_r,(struct _reent *, void *__cookie,
const char *__mode, cookie_io_functions_t __functions));
#endif /* ! __STRICT_ANSI__ */
#ifndef __CUSTOM_FILE_IO__
/*
* The __sfoo macros are here so that we can
* define function versions in the C library.
*/
#define __sgetc_raw_r(__ptr, __f) (--(__f)->_r < 0 ? __srget_r(__ptr, __f) : (int)(*(__f)->_p++))
#ifdef __SCLE
/* For a platform with CR/LF, additional logic is required by
__sgetc_r which would otherwise simply be a macro; therefore we
use an inlined function. The function is only meant to be inlined
in place as used and the function body should never be emitted.
There are two possible means to this end when compiling with GCC,
one when compiling with a standard C99 compiler, and for other
compilers we're just stuck. At the moment, this issue only
affects the Cygwin target, so we'll most likely be using GCC. */
_ELIDABLE_INLINE int __sgetc_r(struct _reent *__ptr, FILE *__p);
_ELIDABLE_INLINE int __sgetc_r(struct _reent *__ptr, FILE *__p)
{
int __c = __sgetc_raw_r(__ptr, __p);
if ((__p->_flags & __SCLE) && (__c == '\r'))
{
int __c2 = __sgetc_raw_r(__ptr, __p);
if (__c2 == '\n')
__c = __c2;
else
ungetc(__c2, __p);
}
return __c;
}
#else
#define __sgetc_r(__ptr, __p) __sgetc_raw_r(__ptr, __p)
#endif
#ifdef _never /* __GNUC__ */
/* If this inline is actually used, then systems using coff debugging
info get hopelessly confused. 21sept93 rich@cygnus.com. */
_ELIDABLE_INLINE int __sputc_r(struct _reent *_ptr, int _c, FILE *_p) {
if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
return (*_p->_p++ = _c);
else
return (__swbuf_r(_ptr, _c, _p));
}
#else
/*
* This has been tuned to generate reasonable code on the vax using pcc
*/
#define __sputc_raw_r(__ptr, __c, __p) \
(--(__p)->_w < 0 ? \
(__p)->_w >= (__p)->_lbfsize ? \
(*(__p)->_p = (__c)), *(__p)->_p != '\n' ? \
(int)*(__p)->_p++ : \
__swbuf_r(__ptr, '\n', __p) : \
__swbuf_r(__ptr, (int)(__c), __p) : \
(*(__p)->_p = (__c), (int)*(__p)->_p++))
#ifdef __SCLE
#define __sputc_r(__ptr, __c, __p) \
((((__p)->_flags & __SCLE) && ((__c) == '\n')) \
? __sputc_raw_r(__ptr, '\r', (__p)) : 0 , \
__sputc_raw_r((__ptr), (__c), (__p)))
#else
#define __sputc_r(__ptr, __c, __p) __sputc_raw_r(__ptr, __c, __p)
#endif
#endif
#define __sfeof(p) (((p)->_flags & __SEOF) != 0)
#define __sferror(p) (((p)->_flags & __SERR) != 0)
#define __sclearerr(p) ((void)((p)->_flags &= ~(__SERR|__SEOF)))
#define __sfileno(p) ((p)->_file)
#ifndef _REENT_SMALL
#define feof(p) __sfeof(p)
#define ferror(p) __sferror(p)
#define clearerr(p) __sclearerr(p)
#endif
#if 0 /*ndef __STRICT_ANSI__ - FIXME: must initialize stdio first, use fn */
#define fileno(p) __sfileno(p)
#endif
#ifndef __CYGWIN__
#ifndef lint
#define getc(fp) __sgetc_r(_REENT, fp)
#define putc(x, fp) __sputc_r(_REENT, x, fp)
#endif /* lint */
#endif /* __CYGWIN__ */
#ifndef __STRICT_ANSI__
/* fast always-buffered version, true iff error */
#define fast_putc(x,p) (--(p)->_w < 0 ? \
__swbuf_r(_REENT, (int)(x), p) == EOF : (*(p)->_p = (x), (p)->_p++, 0))
#define L_cuserid 9 /* posix says it goes in stdio.h :( */
#ifdef __CYGWIN__
#define L_ctermid 16
#endif
#endif
#endif /* !__CUSTOM_FILE_IO__ */
#define getchar() getc(stdin)
#define putchar(x) putc(x, stdout)
_END_STD_C
#endif /* _STDIO_H_ */

226
programs/develop/libraries/newlib/include/stdlib.h Normal file
View File

@ -0,0 +1,226 @@
/*
* 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
#include <stddef.h>
#include <sys/reent.h>
#include <machine/stdlib.h>
#ifndef __STRICT_ANSI__
#include <alloca.h>
#endif
#ifdef __CYGWIN__
#include <cygwin/stdlib.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;
#ifndef __STRICT_ANSI__
typedef struct
{
long long int quot; /* quotient */
long long int rem; /* remainder */
} lldiv_t;
#endif
#ifndef NULL
#define NULL 0
#endif
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define RAND_MAX __RAND_MAX
int _EXFUN(__locale_mb_cur_max,(_VOID));
#define MB_CUR_MAX __locale_mb_cur_max()
_VOID _EXFUN(abort,(_VOID) _ATTRIBUTE ((noreturn)));
int _EXFUN(abs,(int));
int _EXFUN(atexit,(_VOID (*__func)(_VOID)));
double _EXFUN(atof,(const char *__nptr));
#ifndef __STRICT_ANSI__
float _EXFUN(atoff,(const char *__nptr));
#endif
int _EXFUN(atoi,(const char *__nptr));
int _EXFUN(_atoi_r,(struct _reent *, const char *__nptr));
long _EXFUN(atol,(const char *__nptr));
long _EXFUN(_atol_r,(struct _reent *, const char *__nptr));
_PTR _EXFUN(bsearch,(const _PTR __key,
const _PTR __base,
size_t __nmemb,
size_t __size,
int _EXFNPTR(_compar,(const _PTR, const _PTR))));
_PTR _EXFUN_NOTHROW(calloc,(size_t __nmemb, size_t __size));
div_t _EXFUN(div,(int __numer, int __denom));
_VOID _EXFUN(exit,(int __status) _ATTRIBUTE ((noreturn)));
_VOID _EXFUN_NOTHROW(free,(_PTR));
char * _EXFUN(getenv,(const char *__string));
char * _EXFUN(_getenv_r,(struct _reent *, const char *__string));
char * _EXFUN(_findenv,(_CONST char *, int *));
char * _EXFUN(_findenv_r,(struct _reent *, _CONST char *, int *));
#ifndef __STRICT_ANSI__
extern char *suboptarg; /* getsubopt(3) external variable */
int _EXFUN(getsubopt,(char **, char * const *, char **));
#endif
long _EXFUN(labs,(long));
ldiv_t _EXFUN(ldiv,(long __numer, long __denom));
_PTR _EXFUN_NOTHROW(malloc,(size_t __size));
int _EXFUN(mblen,(const char *, size_t));
int _EXFUN(_mblen_r,(struct _reent *, const char *, size_t, _mbstate_t *));
int _EXFUN(mbtowc,(wchar_t *, const char *, size_t));
int _EXFUN(_mbtowc_r,(struct _reent *, wchar_t *, const char *, size_t, _mbstate_t *));
int _EXFUN(wctomb,(char *, wchar_t));
int _EXFUN(_wctomb_r,(struct _reent *, char *, wchar_t, _mbstate_t *));
size_t _EXFUN(mbstowcs,(wchar_t *, const char *, size_t));
size_t _EXFUN(_mbstowcs_r,(struct _reent *, wchar_t *, const char *, size_t, _mbstate_t *));
size_t _EXFUN(wcstombs,(char *, const wchar_t *, size_t));
size_t _EXFUN(_wcstombs_r,(struct _reent *, char *, const wchar_t *, size_t, _mbstate_t *));
#ifndef __STRICT_ANSI__
#ifndef _REENT_ONLY
char * _EXFUN(mkdtemp,(char *));
int _EXFUN(mkostemp,(char *, int));
int _EXFUN(mkostemps,(char *, int, int));
int _EXFUN(mkstemp,(char *));
int _EXFUN(mkstemps,(char *, int));
char * _EXFUN(mktemp,(char *) _ATTRIBUTE ((__warning__ ("the use of `mktemp' is dangerous; use `mkstemp' instead"))));
#endif
char * _EXFUN(_mkdtemp_r, (struct _reent *, char *));
int _EXFUN(_mkostemp_r, (struct _reent *, char *, int));
int _EXFUN(_mkostemps_r, (struct _reent *, char *, int, int));
int _EXFUN(_mkstemp_r, (struct _reent *, char *));
int _EXFUN(_mkstemps_r, (struct _reent *, char *, int));
char * _EXFUN(_mktemp_r, (struct _reent *, char *) _ATTRIBUTE ((__warning__ ("the use of `mktemp' is dangerous; use `mkstemp' instead"))));
#endif
_VOID _EXFUN(qsort,(_PTR __base, size_t __nmemb, size_t __size, int(*_compar)(const _PTR, const _PTR)));
int _EXFUN(rand,(_VOID));
_PTR _EXFUN_NOTHROW(realloc,(_PTR __r, size_t __size));
#ifndef __STRICT_ANSI__
_PTR _EXFUN(reallocf,(_PTR __r, size_t __size));
#endif
_VOID _EXFUN(srand,(unsigned __seed));
double _EXFUN(strtod,(const char *__n, char **__end_PTR));
double _EXFUN(_strtod_r,(struct _reent *,const char *__n, char **__end_PTR));
float _EXFUN(strtof,(const char *__n, char **__end_PTR));
#ifndef __STRICT_ANSI__
/* the following strtodf interface is deprecated...use strtof instead */
# ifndef strtodf
# define strtodf strtof
# endif
#endif
long _EXFUN(strtol,(const char *__n, char **__end_PTR, int __base));
long _EXFUN(_strtol_r,(struct _reent *,const char *__n, char **__end_PTR, int __base));
unsigned long _EXFUN(strtoul,(const char *__n, char **__end_PTR, int __base));
unsigned long _EXFUN(_strtoul_r,(struct _reent *,const char *__n, char **__end_PTR, int __base));
int _EXFUN(system,(const char *__string));
#ifndef __STRICT_ANSI__
long _EXFUN(a64l,(const char *__input));
char * _EXFUN(l64a,(long __input));
char * _EXFUN(_l64a_r,(struct _reent *,long __input));
int _EXFUN(on_exit,(_VOID (*__func)(int, _PTR),_PTR __arg));
_VOID _EXFUN(_Exit,(int __status) _ATTRIBUTE ((noreturn)));
int _EXFUN(putenv,(char *__string));
int _EXFUN(_putenv_r,(struct _reent *, char *__string));
_PTR _EXFUN(_reallocf_r,(struct _reent *, _PTR, size_t));
int _EXFUN(setenv,(const char *__string, const char *__value, int __overwrite));
int _EXFUN(_setenv_r,(struct _reent *, const char *__string, const char *__value, int __overwrite));
char * _EXFUN(gcvt,(double,int,char *));
char * _EXFUN(gcvtf,(float,int,char *));
char * _EXFUN(fcvt,(double,int,int *,int *));
char * _EXFUN(fcvtf,(float,int,int *,int *));
char * _EXFUN(ecvt,(double,int,int *,int *));
char * _EXFUN(ecvtbuf,(double, int, int*, int*, char *));
char * _EXFUN(fcvtbuf,(double, int, int*, int*, char *));
char * _EXFUN(ecvtf,(float,int,int *,int *));
char * _EXFUN(dtoa,(double, int, int, int *, int*, char**));
int _EXFUN(rand_r,(unsigned *__seed));
double _EXFUN(drand48,(_VOID));
double _EXFUN(_drand48_r,(struct _reent *));
double _EXFUN(erand48,(unsigned short [3]));
double _EXFUN(_erand48_r,(struct _reent *, unsigned short [3]));
long _EXFUN(jrand48,(unsigned short [3]));
long _EXFUN(_jrand48_r,(struct _reent *, unsigned short [3]));
_VOID _EXFUN(lcong48,(unsigned short [7]));
_VOID _EXFUN(_lcong48_r,(struct _reent *, unsigned short [7]));
long _EXFUN(lrand48,(_VOID));
long _EXFUN(_lrand48_r,(struct _reent *));
long _EXFUN(mrand48,(_VOID));
long _EXFUN(_mrand48_r,(struct _reent *));
long _EXFUN(nrand48,(unsigned short [3]));
long _EXFUN(_nrand48_r,(struct _reent *, unsigned short [3]));
unsigned short *
_EXFUN(seed48,(unsigned short [3]));
unsigned short *
_EXFUN(_seed48_r,(struct _reent *, unsigned short [3]));
_VOID _EXFUN(srand48,(long));
_VOID _EXFUN(_srand48_r,(struct _reent *, long));
long long _EXFUN(atoll,(const char *__nptr));
long long _EXFUN(_atoll_r,(struct _reent *, const char *__nptr));
long long _EXFUN(llabs,(long long));
lldiv_t _EXFUN(lldiv,(long long __numer, long long __denom));
long long _EXFUN(strtoll,(const char *__n, char **__end_PTR, int __base));
long long _EXFUN(_strtoll_r,(struct _reent *, const char *__n, char **__end_PTR, int __base));
unsigned long long _EXFUN(strtoull,(const char *__n, char **__end_PTR, int __base));
unsigned long long _EXFUN(_strtoull_r,(struct _reent *, const char *__n, char **__end_PTR, int __base));
#ifndef __CYGWIN__
_VOID _EXFUN(cfree,(_PTR));
int _EXFUN(unsetenv,(const char *__string));
int _EXFUN(_unsetenv_r,(struct _reent *, const char *__string));
#endif
#ifdef __rtems__
int _EXFUN(posix_memalign,(void **, size_t, size_t));
#endif
#endif /* ! __STRICT_ANSI__ */
char * _EXFUN(_dtoa_r,(struct _reent *, double, int, int, int *, int*, char**));
#ifndef __CYGWIN__
_PTR _EXFUN_NOTHROW(_malloc_r,(struct _reent *, size_t));
_PTR _EXFUN_NOTHROW(_calloc_r,(struct _reent *, size_t, size_t));
_VOID _EXFUN_NOTHROW(_free_r,(struct _reent *, _PTR));
_PTR _EXFUN_NOTHROW(_realloc_r,(struct _reent *, _PTR, size_t));
_VOID _EXFUN(_mstats_r,(struct _reent *, char *));
#endif
int _EXFUN(_system_r,(struct _reent *, const char *));
_VOID _EXFUN(__eprintf,(const char *, const char *, unsigned int, const char *));
/* On platforms where long double equals double. */
#ifdef _LDBL_EQ_DBL
extern long double strtold (const char *, char **);
extern long double wcstold (const wchar_t *, wchar_t **);
#endif /* _LDBL_EQ_DBL */
_END_STD_C
#endif /* _STDLIB_H_ */

104
programs/develop/libraries/newlib/include/string.h Normal file
View File

@ -0,0 +1,104 @@
/*
* string.h
*
* Definitions for memory and string functions.
*/
#ifndef _STRING_H_
#define _STRING_H_
#include "_ansi.h"
#include <sys/reent.h>
#define __need_size_t
#include <stddef.h>
#ifndef NULL
#define NULL 0
#endif
_BEGIN_STD_C
_PTR _EXFUN(memchr,(const _PTR, int, size_t));
int _EXFUN(memcmp,(const _PTR, const _PTR, size_t));
_PTR _EXFUN(memcpy,(_PTR, const _PTR, size_t));
_PTR _EXFUN(memmove,(_PTR, const _PTR, size_t));
_PTR _EXFUN(memset,(_PTR, int, size_t));
char *_EXFUN(strcat,(char *, const char *));
char *_EXFUN(strchr,(const char *, int));
int _EXFUN(strcmp,(const char *, const char *));
int _EXFUN(strcoll,(const char *, const char *));
char *_EXFUN(strcpy,(char *, const char *));
size_t _EXFUN(strcspn,(const char *, const char *));
char *_EXFUN(strerror,(int));
size_t _EXFUN(strlen,(const char *));
char *_EXFUN(strncat,(char *, const char *, size_t));
int _EXFUN(strncmp,(const char *, const char *, size_t));
char *_EXFUN(strncpy,(char *, const char *, size_t));
char *_EXFUN(strpbrk,(const char *, const char *));
char *_EXFUN(strrchr,(const char *, int));
size_t _EXFUN(strspn,(const char *, const char *));
char *_EXFUN(strstr,(const char *, const char *));
#ifndef _REENT_ONLY
char *_EXFUN(strtok,(char *, const char *));
#endif
size_t _EXFUN(strxfrm,(char *, const char *, size_t));
#ifndef __STRICT_ANSI__
char *_EXFUN(strtok_r,(char *, const char *, char **));
int _EXFUN(bcmp,(const void *, const void *, size_t));
void _EXFUN(bcopy,(const void *, void *, size_t));
void _EXFUN(bzero,(void *, size_t));
int _EXFUN(ffs,(int));
char *_EXFUN(index,(const char *, int));
_PTR _EXFUN(memccpy,(_PTR, const _PTR, int, size_t));
_PTR _EXFUN(mempcpy,(_PTR, const _PTR, size_t));
_PTR _EXFUN(memmem, (const _PTR, size_t, const _PTR, size_t));
char *_EXFUN(rindex,(const char *, int));
char *_EXFUN(stpcpy,(char *, const char *));
char *_EXFUN(stpncpy,(char *, const char *, size_t));
int _EXFUN(strcasecmp,(const char *, const char *));
char *_EXFUN(strcasestr,(const char *, const char *));
char *_EXFUN(strdup,(const char *));
char *_EXFUN(_strdup_r,(struct _reent *, const char *));
char *_EXFUN(strndup,(const char *, size_t));
char *_EXFUN(_strndup_r,(struct _reent *, const char *, size_t));
char *_EXFUN(strerror_r,(int, char *, size_t));
size_t _EXFUN(strlcat,(char *, const char *, size_t));
size_t _EXFUN(strlcpy,(char *, const char *, size_t));
int _EXFUN(strncasecmp,(const char *, const char *, size_t));
size_t _EXFUN(strnlen,(const char *, size_t));
char *_EXFUN(strsep,(char **, const char *));
char *_EXFUN(strlwr,(char *));
char *_EXFUN(strupr,(char *));
#ifdef __CYGWIN__
#ifndef DEFS_H /* Kludge to work around problem compiling in gdb */
char *_EXFUN(strsignal, (int __signo));
#endif
int _EXFUN(strtosigno, (const char *__name));
#endif
/* These function names are used on Windows and perhaps other systems. */
#ifndef strcmpi
#define strcmpi strcasecmp
#endif
#ifndef stricmp
#define stricmp strcasecmp
#endif
#ifndef strncmpi
#define strncmpi strncasecmp
#endif
#ifndef strnicmp
#define strnicmp strncasecmp
#endif
#endif /* ! __STRICT_ANSI__ */
#include <sys/string.h>
_END_STD_C
#endif /* _STRING_H_ */

Some files were not shown because too many files have changed in this diff Show More